npm - @wildo-ai/saas-backend-lib - Versions diffs - 1.1.3 → 1.1.4 - Mend

@wildo-ai/saas-backend-lib 1.1.3 → 1.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1056) hide show

package/dist/esm/flows-actors/a2a/models/a2a.backend.schemas.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a.backend.schemas.d.ts","sourceRoot":"","sources":["~~../../../../../../~~src/flows-actors/a2a/models/a2a.backend.schemas.ts"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"a2a.backend.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/models/a2a.backend.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/flows-actors/a2a/models/a2a.backend.schemas.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a.backend.schemas.js","sourceRoot":"","sources":["../../../../../../src/flows-actors/a2a/models/a2a.backend.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { FLOWS_ACTORS_DEFAULT_AGENT_INSTANCE, FlowsActors_Status } from '@wildo-ai/saas-models';\n\n/*\n Backend-local contracts for the inbound Agent2Agent (A2A) JSON-RPC transport.\n * The public card advertises both A2A 1.0 and the legacy 0.2.5 dialect; the\n * controller normalizes both vocabularies onto these canonical message, task,\n * push-notification and agent-card shapes.\n \n Kept backend-local (not `saas-models`) on purpose: no frontend or\n * cross-package consumer owns the A2A wire representation. The conversational\n * runtime remains transport-agnostic; this module owns only the external\n * protocol boundary and the dialect-neutral shapes used by the controller.\n /\n\n/* Legacy scalar version retained for 0.2.5 clients that do not read `supportedInterfaces`. /\nexport const A2A_PROTOCOL_VERSION = '0.2.5';\n\n/\n The transport name for this surface's JSON-RPC binding, as `AgentInterface.transport` spells it.\n \n spec-cite: A2A 1.0 §5.3 — the binding table's JSON-RPC column; the proto's `AgentInterface`\n * carries the transport alongside the url and version.\n /\nexport const A2A_JSONRPC_TRANSPORT = 'JSONRPC';\n\n/* A2A message roles. External callers send `user`; the agent replies as `agent`. /\nexport enum A2A_MessageRole {\n USER = 'user',\n AGENT = 'agent',\n}\n\n/\n A single text part of an A2A message. A2A also defines `file` and `data`\n * parts; this slice consumes/produces TEXT only (the conversational runtime is\n * text-in/markdown-out) and fails closed on a message with no text part.\n /\nexport const A2A_TextPartSchema: z.ZodObject<{\n kind: z.ZodLiteral<'text'>;\n text: z.ZodString;\n}> = z.object({\n kind: z.literal('text'),\n text: z.string(),\n});\n\n/\n An inbound A2A part. Non-text parts are tolerated on the wire (passthrough,\n * unknown-key-preserving) but ignored by the text-only mapping — we never reject\n * a caller for sending a richer part, we just read the text.\n /\nexport const A2A_InboundPartSchema: z.ZodType<Record<string, unknown>> = z.looseObject({\n kind: z.string(),\n});\n\n/* Inbound A2A message (the `params.message` of a `message/send` / `message/stream`). /\nexport const A2A_InboundMessageSchema: z.ZodObject<{\n role: z.ZodOptional<z.ZodEnum<typeof A2A_MessageRole>>;\n parts: z.ZodArray<typeof A2A_InboundPartSchema>;\n messageId: z.ZodOptional<z.ZodString>;\n taskId: z.ZodOptional<z.ZodString>;\n contextId: z.ZodOptional<z.ZodString>;\n metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;\n}> = z.object({\n role: z.enum(A2A_MessageRole).optional(),\n parts: z.array(A2A_InboundPartSchema),\n messageId: z.string().optional(),\n /\n A2A task continuation — \"this message belongs to task X\".\n \n DECLARED AND REJECTED, not declared-and-ignored (review finding A3-9). This transport opens a\n * task per non-inline turn and has no continuation runtime, so honouring the field is a later\n * phase. The two alternatives to rejecting are both worse: dropping it from the schema strips it\n * silently (still reading as supported), and accepting it would open a SECOND task for a message\n * the client explicitly attached to a first — a divergence the client cannot see. The controller\n * therefore answers `INVALID_PARAMS` naming `contextId` as the supported way to continue a thread.\n /\n taskId: z.string().optional(),\n contextId: z.string().optional(),\n metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\n/\n `configuration` of an A2A `message/send` / `message/stream` call.\n \n ## `blocking` is the protocol's field. `returnImmediately` never existed.\n \n ⚠️ An earlier revision keyed the whole task plane on `configuration.returnImmediately`, described\n * as \"the PROTOCOL's own answer to whether this turn is inline\" and supported by quotations\n * attributed to the specification. *The field is not in A2A, and the quotations are not in the\n specification.** v0.2.5 defines `MessageSendConfiguration` as\n * `{ acceptedOutputModes, historyLength?, pushNotificationConfig?, blocking? }`, where `blocking` is\n * documented as \"If the server should treat the client as a blocking request\".\n \n The consequence was not cosmetic: every mechanism built on the trigger — task materialisation,\n * `tasks/get`, `tasks/cancel`, the Redis lease and cancel broadcast, the compare-and-swap, the\n * abandoned-task sweep — was reachable only by a client sending a Wildo-invented field. A\n * conformant client asking for exactly this behaviour with `{\"blocking\": false}` got a blocking\n * call and could never obtain a task id.\n \n The sense is also INVERTED from the field it replaced, so this is not a rename:\n * `returnImmediately: true` ⇒ `blocking: false`.\n \n Absent means blocking. The spec makes the field optional and prescribes no default, so the\n * choice is ours: a client that says nothing keeps the inline `Message` reply, which preserves the\n * hot-path property D-P1-1 exists for (no task row per turn) and changes nothing for existing\n * callers. Only an explicit `blocking: false` opts into a task.\n \n `z.looseObject` on purpose: the configuration carries further fields this transport does not\n * implement yet (`acceptedOutputModes`, `historyLength`, `pushNotificationConfig`), and dropping\n * unknown keys silently would make a future client's request look accepted while its intent was\n * discarded.\n /\nexport const A2A_MessageSendConfigurationSchema: z.ZodType<Record<string, unknown>> = z.looseObject({\n blocking: z.boolean().optional(),\n});\n\n/\n Does this configuration ask for a NON-BLOCKING turn — i.e. a task the client will poll?\n \n The one place the protocol field is interpreted, so the inversion lives here rather than at each\n * call site. `undefined` is deliberately NOT non-blocking; see the schema note above.\n /\nexport function requestsNonBlockingTurn(configuration: unknown): boolean {\n return (configuration as { blocking?: unknown } \| undefined)?.blocking === false;\n}\n\n/* `params` of an A2A `message/send` / `message/stream` call. /\n/\n ⚠️ `looseObject`, and the strict version was a REAL defect — found live, not in review.\n \n A2A 1.0 puts its non-blocking flag at the TOP LEVEL (`return_immediately`), where v0.2.5 nests it\n * under `configuration.blocking`. A strict `z.object` silently STRIPS unknown top-level keys, so\n * `return_immediately` never survived the parse: a 1.0 client's request for a non-blocking turn was\n * discarded, the turn blocked, and the response was a `Message` where the client expected a `Task`.\n * No error anywhere — the client simply looked broken.\n \n The reasoning was already written down TWICE in this very file, on\n * `A2A_MessageSendConfigurationSchema` and `A2A_TaskIdParamsSchema`: \"dropping unknown keys\n silently would make a future client's request look accepted while its intent was discarded.\"\n This schema was the one sibling that did not follow it, and the cost was exactly the one predicted.\n /\nexport const A2A_MessageSendParamsSchema: z.ZodType<{\n message: z.infer<typeof A2A_InboundMessageSchema>;\n configuration?: Record<string, unknown>;\n metadata?: Record<string, unknown>;\n}> = z.looseObject({\n message: A2A_InboundMessageSchema,\n configuration: A2A_MessageSendConfigurationSchema.optional(),\n metadata: z.record(z.string(), z.unknown()).optional(),\n}) as unknown as z.ZodType<{\n message: z.infer<typeof A2A_InboundMessageSchema>;\n configuration?: Record<string, unknown>;\n metadata?: Record<string, unknown>;\n}>;\n\n/\n `params` of an A2A `tasks/get` / `tasks/cancel` call — both address a task by id.\n \n `looseObject` for the same reason the send configuration uses it (review finding L-4): the spec\n * carries further fields here — `historyLength` on `tasks/get` — that this transport does not\n * implement. A strict object DROPS them silently, so the request looks accepted while the client's\n * intent was discarded. Tolerating-and-ignoring is honest; the fields simply have no effect yet.\n \n `id` stays `z.string()`, which is also the NoSQL-operator-injection boundary: an object here\n * would otherwise reach the owner filter as a query operator.\n /\nexport const A2A_TaskIdParamsSchema: z.ZodType<{ id: string; metadata?: Record<string, unknown> }> = z.looseObject({\n id: z.string().min(1),\n metadata: z.record(z.string(), z.unknown()).optional(),\n}) as unknown as z.ZodType<{ id: string; metadata?: Record<string, unknown> }>;\nexport type A2A_TaskIdParams = z.infer<typeof A2A_TaskIdParamsSchema>;\n\n/* JSON-RPC 2.0 request envelope for the A2A endpoint. /\nexport const A2A_JsonRpcRequestSchema: z.ZodObject<{\n jsonrpc: z.ZodLiteral<'2.0'>;\n id: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;\n method: z.ZodString;\n params: z.ZodOptional<z.ZodUnknown>;\n}> = z.object({\n jsonrpc: z.literal('2.0'),\n id: z.union([z.string(), z.number(), z.null()]),\n method: z.string(),\n params: z.unknown().optional(),\n});\n\nexport type A2A_JsonRpcRequest = z.infer<typeof A2A_JsonRpcRequestSchema>;\nexport type A2A_MessageSendParams = z.infer<typeof A2A_MessageSendParamsSchema>;\n\n/\n JSON-RPC error codes for this transport, split into the two ranges that actually exist.\n \n ## The numbering is SPEC-CONFORMANT, and that was a correction\n \n A2A assigns SIX codes in this block: `-32001` TaskNotFound, `-32002` TaskNotCancelable,\n * `-32003` PushNotificationNotSupported, `-32004` UnsupportedOperation, `-32005`\n * ContentTypeNotSupported, `-32006` InvalidAgentResponse. `-32007`..`-32009` are UNASSIGNED in\n * v0.2.5.\n * spec-cite: A2A v0.2.5 §8.2 (error code assignments)\n \n An earlier revision of this enum occupied five of those slots with Wildo meanings, so a\n * conformant client mis-read every one — an unknown skill answered `-32002`, which the spec defines\n * as TaskNotCancelable, so the client was told the task could not be canceled.\n * spec-cite: N/A — that reading is the MEANING a client derives from the code, not a quotation.\n \n spec-cite: N/A — the sentence quoted just below is this file's OWN retired claim, reproduced so\n * the error is legible; it is not attributed to the specification.\n \n ⚠️ THE COUNT HAS NOW BEEN WRONG TWICE IN THIS BLOCK, which is worth more than the correction.\n * The first note flagged only the `-32001` clash and picked `-32005` without noticing it too was\n * assigned. The SECOND said the spec assigns nine and that \"every slot was taken; there was never a\n * free one to move into\" — and a later pass added a `spec-cite:` marker directly beneath it, so a\n * citation ended up vouching for a number nobody had checked. A citation records WHERE to look; it\n * is not evidence that anyone looked. Re-derive counts from the document, never from this block.\n \n Reserving `-32007`..`-32009` rather than using them is therefore a WILDO CHOICE, not a necessity:\n * they are free today, and leaving them alone keeps the Wildo range from colliding with codes a\n * future A2A version may assign.\n \n The resolution keeps the two ranges apart:\n \n - -32001..-32009 — A2A's, used ONLY with A2A's meanings. Adding a code here means adopting\n * the spec's error for it, never inventing one.\n * - -32010..-32099 — Wildo's. JSON-RPC 2.0 reserves `-32000..-32099` for implementation-defined\n * server errors, and A2A assigns nothing above `-32006`, so this is genuinely free. Wildo\n * concerns that the protocol has no vocabulary for (authentication, skill routing, rate limits,\n * spend caps) live here and cannot collide with a future spec code below `-32010`.\n \n Renumbering was a WIRE change to a shipped surface; it is safe here only because this is a\n * greenfield project, and the e2e assertions that pinned the old literals were moved with it.\n /\nexport enum A2A_JsonRpcErrorCode {\n // ── JSON-RPC 2.0 standard ────────────────────────────────────────────────────────────────\n PARSE_ERROR = -32700,\n INVALID_REQUEST = -32600,\n METHOD_NOT_FOUND = -32601,\n INVALID_PARAMS = -32602,\n INTERNAL_ERROR = -32603,\n\n // ── A2A-assigned (-32001..-32009): the spec's codes, with the spec's meanings ─────────────\n /* A2A `TaskNotFoundError`: the addressed task does not exist, or is not visible to this caller. /\n TASK_NOT_FOUND = -32001,\n /\n A2A `TaskNotCancelableError`: the task is already terminal, so it cannot be canceled.\n \n spec-cite: A2A v0.2.5 §7.4 (tasks/cancel error list, permissive tone) — and N/A for the quoted\n * `\"MUST NOT succeed\"`, which appears here BECAUSE it is false, and for the two client-outcome\n * phrases, which are not document text.\n \n ⚠️ A WILDO DESIGN DECISION, not a protocol requirement — and an earlier revision of this note\n * claimed otherwise by quoting `\"MUST NOT succeed\"` as specification text. *That string is not in\n v0.2.5.** §7.4 is permissive in tone (\"the server will attempt to cancel… but success is not\n * guaranteed\") and lists `TaskNotCancelableError` among its example errors. So the spec PERMITS\n * this answer; it does not mandate it.\n \n spec-cite: N/A — the two phrases below are the OUTCOMES a client could not tell apart, not\n * text from the document.\n \n The reason we choose it stands on its own, which is why the correction changes no behaviour:\n * answering 200 with the task makes \"I stopped it\" and \"it had already finished\"\n * indistinguishable on the wire, and those are different outcomes to anything reconciling state.\n * The task remains readable via `tasks/get` either way.\n /\n TASK_NOT_CANCELABLE = -32002,\n /\n A2A `PushNotificationNotSupportedError`: the agent does not support webhook task updates.\n \n Returned by all four push-notification-configuration operations whenever the agent card\n * advertises `capabilities.pushNotifications: false`. The norm makes this a MUST, and it is not\n * interchangeable with `METHOD_NOT_FOUND`: a client that receives `-32601` cannot distinguish\n * \"this agent does not do push notifications\" from \"this agent is not A2A-compliant\", whereas\n * `-32003` tells it exactly which capability to stop asking for.\n \n spec-cite: A2A 1.0 §3.3.4 — \"If `AgentCard.capabilities.pushNotifications` is `false` or not\n present, operations related to push notification configuration (Create, Get, List, Delete)\n * MUST return `PushNotificationNotSupportedError`\"* — and §5.4, which assigns it the JSON-RPC\n * code `-32003` (gRPC `FAILED_PRECONDITION`, HTTP `400 Bad Request`).\n /\n PUSH_NOTIFICATION_NOT_SUPPORTED = -32003,\n /\n A2A `UnsupportedOperationError`: the agent does not support this operation.\n \n Distinct from `METHOD_NOT_FOUND` in exactly the way `-32003` is: `-32601` says \"this server does\n * not know that method\", which a client cannot tell from a misrouted or non-compliant server, so\n * it retries or reports a transport fault. `-32004` says \"this agent knows the operation and does\n * not offer it\" — permanent, cacheable, actionable.\n \n spec-cite: A2A 1.0 §5.4 assigns `UnsupportedOperationError` the JSON-RPC code `-32004` (gRPC\n * `FAILED_PRECONDITION`, HTTP `400 Bad Request`); §3.3.4 — \"If `AgentCard.capabilities.\n extendedAgentCard` is `false` or not present, attempts to call the Get Extended Agent Card\n * operation MUST return `UnsupportedOperationError`\".\n /\n UNSUPPORTED_OPERATION = -32004,\n\n // ── Wildo-assigned (-32010..-32099): concerns A2A has no vocabulary for ───────────────────\n /** The caller is unauthenticated / the token is invalid. /\n UNAUTHENTICATED = -32010,\n /* The referenced skill / actor system does not exist, or is outside this agent's subset. /\n SKILL_NOT_FOUND = -32011,\n /\n The caller exceeded the per-principal turn rate cap. Ridden by a transport-level HTTP 429 +\n * `Retry-After` (throttling is a transport concern), unlike the codes above which ride HTTP 200\n * per JSON-RPC. The body stays a valid JSON-RPC error so strict clients still parse it.\n /\n RATE_LIMITED = -32012,\n /\n The caller's tenant has exhausted its plan-granted LLM token budget for the current period.\n * Ridden by a transport-level HTTP 402 — deliberately NOT the 429 + `Retry-After` of\n * {@link RATE_LIMITED}: a spend cap is not a rolling-window throttle, so the client's correct\n * reaction is to upgrade the plan or wait for the period to roll, not to retry after N seconds.\n * 402 matches the existing `FEATURE_LIMIT_EXCEEDED` / `INSUFFICIENT_CREDITS` billing mapping.\n /\n BUDGET_EXCEEDED = -32013,\n}\n\n/\n @wildo_source:part:start saas.backend.flows-actors.a2a-task-surface facet:layer:backend facet:family:flows-actors\n \n The A2A TASK surface your app exposes to external agents. You never author these —\n * the engine serves them — but knowing the contract tells you what an agent client can\n * do with a turn your actor system runs.\n \n A task is materialised ONLY when a turn cannot complete inline:\n * - the client sent `configuration.blocking: false` (the A2A field — absent means blocking), or\n * - the turn reached an interrupted state (a human-in-the-loop approval pause).\n \n BOTH triggers are live. The interrupted-state arm needs a runtime that can pause a turn; that\n * is the human-in-the-loop approval gate, and a paused turn now materialises a task carrying\n * `input-required` on all three transports (blocking send, non-blocking send, stream). An earlier\n * revision of this note warned that the arm was inert and `input-required` never emitted — true\n * when written, and left here in corrected form because a reader who remembers the old claim would\n * otherwise conclude the state is decorative and safe to drop.\n \n A blocking turn that answers in one shot returns an A2A `Message` and writes no task\n * row at all. Both shapes are protocol-conformant: the specification types the\n * `message/send` result as `Task \| Message`, so returning either is conformance rather than a\n * shortcut. The inline case is the default so a chatty agent does not accumulate a row per turn.\n * spec-cite: A2A v0.2.5 §7.1 (SendMessageResponse result type)\n \n \n * Once a task exists the client can poll it with `tasks/get` and stop it with\n * `tasks/cancel`. Cancel is a STATUS TRANSITION, never a delete: the spec requires it to\n * return the task's updated state, so a cancelled task stays readable.\n \n ⚠️ What cancel does and does not guarantee. It always records the cancellation, and\n * it aborts the model call for the streaming API transports — which is every agent using\n * the standard text/chat operations. It does NOT interrupt two cases: an agent whose\n * transport buffers its whole reply (a CLI-transport agent, or a non-text operation), and\n * a tool call already in flight — those finish, and only then does the turn stop. So\n * cancel is best read as \"stop as soon as the runtime is able\", not \"stop instantly\".\n * The task record is the truth about the request either way.\n \n Import path: `@wildo-ai/saas-backend-lib`.\n /\n/\n ⚠️ DOCUMENTATION-ONLY. Nothing implements this interface — it exists to give the anchored\n * excerpt a typed shape an app builder can read. The real methods are\n * `A2ATaskBackendService.readTask` / `advanceTask`, whose signatures differ (they take an\n * owner scope). Do not `implements` this; keep it in step with the service by hand, or\n * delete it if it ever drifts.\n /\nexport interface A2A_TaskSurfaceContract {\n /* `tasks/get` — read one task by id. Returns the task in its current state. /\n tasksGet: (taskId: string) => Promise<A2A_OutboundTask \| undefined>;\n /* `tasks/cancel` — request cancellation; returns the task's UPDATED state. /\n tasksCancel: (taskId: string) => Promise<A2A_OutboundTask \| undefined>;\n}\n\n/\n A2A task lifecycle states — the PROTOCOL's closed vocabulary (v0.2.5).\n \n Declared as a named enum rather than inline literals because it is exactly the\n * kind of closed semantic vocabulary that must have one runtime source: the\n * projection from `FlowsActors_Status` reads it, the transport emits it, and tests\n * pin it.\n \n Not every member is emitted by this transport today — `AUTH_REQUIRED` and\n * `REJECTED` have no `FlowsActors_Status` counterpart and are never produced. They\n * are declared because the vocabulary belongs to the protocol, not to us: a client\n * may legitimately receive them from another A2A server, and omitting them would\n * invite a future contributor to invent a second, partial enum.\n /\nexport enum A2A_TaskState {\n /* Acknowledged, not yet processing. /\n SUBMITTED = 'submitted',\n /* Actively being processed. /\n WORKING = 'working',\n /\n Interrupted (non-terminal): the agent needs input. The current transport emits this when a\n * user-delegated turn reaches an approval-gated tool, persists the signed pending decision and\n * materialises an addressable task. Approval or refusal resumes that same execution; machine\n * principals are denied rather than parked because no named person can answer for them.\n /\n INPUT_REQUIRED = 'input-required',\n /* Interrupted (non-terminal): authentication needed. NOT emitted by this transport. /\n AUTH_REQUIRED = 'auth-required',\n /* Terminal: finished successfully. /\n COMPLETED = 'completed',\n /* Terminal: finished with error. /\n FAILED = 'failed',\n /* Terminal: canceled before completion. /\n CANCELED = 'canceled',\n /* Terminal: refused by the agent. NOT emitted by this transport. /\n REJECTED = 'rejected',\n /\n Terminal: the agent cannot determine the task's state.\n \n Declared for the same reason as `AUTH_REQUIRED` and `REJECTED` — the enum's rule is that the\n * protocol vocabulary is represented in full so nobody invents a second, partial one. It was\n * simply missed: the spec defines NINE states and this declared eight (review finding G5-6).\n * Never emitted by this transport, which always knows a task's state or cannot find the row.\n /\n UNKNOWN = 'unknown',\n}\n\n/* States after which no further work occurs — a terminal task cannot be canceled. /\nexport const A2A_TERMINAL_TASK_STATES: ReadonlySet<A2A_TaskState> = new Set([\n A2A_TaskState.COMPLETED,\n A2A_TaskState.FAILED,\n A2A_TaskState.CANCELED,\n A2A_TaskState.REJECTED,\n A2A_TaskState.UNKNOWN,\n]);\n/* @wildo_source:part:end saas.backend.flows-actors.a2a-task-surface /\n\n/\n Deliberately OUTSIDE the `@wildo_source` anchor above: this is an authoring correction for\n * framework maintainers, and the anchored span ships verbatim into application-facing skills\n * where neither the anchor nor this repository's revision history exists.\n \n ⚠️ An earlier revision of the `message/send` paragraph above supported its conclusion with a\n * QUOTATION — \"the agent MAY create a new Task … or MAY return a direct Message response for\n * simple interactions\" — attributed to the A2A specification. It is not in the document.\n * spec-cite: N/A — that sentence is quoted precisely BECAUSE it is absent from A2A v0.2.5; it is\n * the defect, not the standard's words.\n \n The conclusion was right and the authority was invented, and because the block was anchored it\n * shipped that invention into the app-facing skill. Cite the TYPE, which is checkable in one step,\n * not a remembered sentence. See `.claude/rules/external-specification-citations.md`.\n /\n\n/\n Project the engine's persisted lifecycle status onto the A2A protocol vocabulary.\n \n This is the ONLY place the two vocabularies meet, and it is exhaustive by\n * construction — `FlowsActors_Status` is a closed enum, so adding a member without\n * deciding its protocol meaning is a compile error at the `satisfies` below rather\n * than a silent fallthrough to some default state.\n \n Both `READY` and `PENDING` project to `SUBMITTED`: the protocol draws its line at\n * \"acknowledged but not yet processing\", and our two pre-processing states are on the\n * same side of it. `ABORTED` projects to `FAILED` rather than `CANCELED` deliberately —\n * `CANCELED` means a caller asked for it, whereas `ABORTED` is the runtime halting\n * itself (e.g. a tripped circuit breaker), which a client should read as a failure it\n * did not request.\n /\nconst A2A_STATE_BY_FLOWS_ACTORS_STATUS = {\n [FlowsActors_Status.READY]: A2A_TaskState.SUBMITTED,\n [FlowsActors_Status.PENDING]: A2A_TaskState.SUBMITTED,\n [FlowsActors_Status.PROCESSING]: A2A_TaskState.WORKING,\n [FlowsActors_Status.AWAITING_APPROVAL]: A2A_TaskState.INPUT_REQUIRED,\n [FlowsActors_Status.COMPLETED]: A2A_TaskState.COMPLETED,\n [FlowsActors_Status.FAILED]: A2A_TaskState.FAILED,\n [FlowsActors_Status.CANCELLED]: A2A_TaskState.CANCELED,\n [FlowsActors_Status.ABORTED]: A2A_TaskState.FAILED,\n} satisfies Record<FlowsActors_Status, A2A_TaskState>;\n\n/* Project a persisted task status onto its A2A protocol state. /\nexport function toA2ATaskState(status: FlowsActors_Status): A2A_TaskState {\n return A2A_STATE_BY_FLOWS_ACTORS_STATUS[status];\n}\n\n/* True when the persisted status is one the protocol treats as terminal. /\nexport function isTerminalA2ATaskStatus(status: FlowsActors_Status): boolean {\n return A2A_TERMINAL_TASK_STATES.has(toA2ATaskState(status));\n}\n\n/\n The stored instance identity of the DEFAULT (unnamed) A2A agent.\n \n Declared instance refs are constrained to `^[a-z0-9][a-z0-9-]$`, so the `` characters make\n * this value unreachable by any real ref — the default agent gets its own identity on the task\n * plane without a collision, and without the filter having to special-case an absent field.\n /\nexport const A2A_DEFAULT_INSTANCE_REF: string = FLOWS_ACTORS_DEFAULT_AGENT_INSTANCE;\n\n/\n States in which a task is waiting on something OUTSIDE the runtime — a human approval, an\n * authentication step — rather than executing on any pod.\n \n ## Why this is a THIRD class and not a shade of \"non-terminal\" (review finding A3-3)\n \n The liveness design asks one question: \"a pod claimed this work — is that pod still alive?\"\n * That question is only meaningful while a pod is actually executing. Splitting statuses merely\n * into terminal / non-terminal conflates two very different non-terminal situations:\n \n - executing — a pod holds the turn and refreshes a lease. No lease ⇒ the pod died ⇒ the\n * task is abandoned, and reporting the stored `working` forever would be a lie.\n * - interrupted — nobody is executing, deliberately. The lease is released the moment the\n * turn unwinds, so a paused task has no lease BY DESIGN. Applying the abandonment rule here\n * reads a correct pause as a dead pod.\n \n With only the two-way split, a task paused for approval read as `failed` on the very next\n * poll and the sweep then made that durable within the grace window — so the approval seam\n * Phase 1 claims to have prepared would have been destroyed by Phase 1's own liveness rules\n * before Phase 2 could use it. A human approval takes minutes to hours; a lease TTL is 30s.\n \n Deliberately OUTSIDE the `@wildo_source` anchor above: this is engine-internal liveness\n * taxonomy, not app-facing protocol surface, and widening the shipped contract with states this\n * transport cannot yet reach is the mistake finding G2-3 recorded.\n /\nexport const A2A_INTERRUPTED_TASK_STATES: ReadonlySet<A2A_TaskState> = new Set([\n A2A_TaskState.INPUT_REQUIRED,\n A2A_TaskState.AUTH_REQUIRED,\n]);\n\n/\n True when the task's status is one whose truthfulness depends on a pod being alive — i.e.\n * neither terminal nor interrupted.\n \n This is the ONLY predicate that should gate derive-on-read downgrades and the abandoned-task\n * sweep. Using `!isTerminalA2ATaskStatus(...)` for that purpose is the A3-3 defect.\n /\nexport function isLivenessGovernedA2ATaskStatus(status: FlowsActors_Status): boolean {\n const state = toA2ATaskState(status);\n return !A2A_TERMINAL_TASK_STATES.has(state) && !A2A_INTERRUPTED_TASK_STATES.has(state);\n}\n\n/\n The persisted statuses a task may still be advanced FROM — everything non-terminal.\n \n This is the compare-and-swap set for `advanceTask` (finding A3-2). Note it deliberately\n * INCLUDES the interrupted states: a task paused for approval must remain cancellable, and\n * Phase 2 must be able to resume it. \"Cannot be advanced\" means terminal, nothing else.\n /\nexport const ADVANCEABLE_TASK_STATUSES: FlowsActors_Status[] =\n (Object.values(FlowsActors_Status) as FlowsActors_Status[]).filter((status) => !isTerminalA2ATaskStatus(status));\n\n/\n The persisted statuses whose stored value is only trustworthy while a pod is alive — the\n * candidate set for the abandoned-task sweep and for the derive-on-read downgrade.\n \n Strictly NARROWER than {@link ADVANCEABLE_TASK_STATUSES}: an interrupted task is advanceable\n * but is not abandoned merely because no pod holds it. Both are derived from the single status\n * projection above, so a new `FlowsActors_Status` member lands in the right set automatically\n * once its protocol meaning is decided.\n /\nexport const LIVENESS_GOVERNED_TASK_STATUSES: FlowsActors_Status[] =\n (Object.values(FlowsActors_Status) as FlowsActors_Status[]).filter(isLivenessGovernedA2ATaskStatus);\n\n/\n WHY an absent lease is absent — the difference between a VERDICT and a failed enquiry.\n \n ## The inversion this vocabulary exists to name (review finding S-1a)\n \n \"No lease\" was a single answer with two incompatible meanings, and the sweep read both as\n * death:\n \n - a pod held this task and stopped refreshing — the lease existed and lapsed. That is\n * abandonment, and repairing the row is the sweep's whole purpose.\n * - this task's liveness was never observable at all — the owning pod could not write the\n * lease (its own Redis connection is broken while the sweep's is fine, or it started the turn\n * with no client at all). The turn is HEALTHY and running; nothing about it is knowable from\n * the lease.\n \n The two are indistinguishable from a single read of one key, so the write side leaves a second,\n * long-lived ESTABLISHMENT marker whenever it successfully writes a lease. Its presence is what\n * turns an absent lease into evidence; its absence is what makes the reading indeterminate.\n \n `isLeaseMechanismWritable` does NOT cover this: it is evaluated on the SWEEP's pod, so a\n * per-pod outage on the executing pod passes it unnoticed. That check answers \"can the fleet's\n * liveness signal be trusted at all\"; this answers \"does this one task's missing lease mean\n * anything\".\n \n Four members, not two, because \"do not act\" has two causes that want opposite follow-ups: one\n * makes progress toward a verdict on a later run, the other learned nothing at all and must not\n * be recorded as though it had. Merging them is the semantic collapse this framework refuses.\n /\nexport enum A2A_AbandonmentEvidence {\n /\n The task's lease was demonstrably established and has since lapsed. A pod claimed this work\n * and stopped refreshing — the classic dead-pod signature, and a VERDICT.\n /\n LEASE_LAPSED = 'lease-lapsed',\n /\n No establishment marker, but a PRIOR sweep run recorded the same absence and that observation\n * is still standing. Two observations separated by at least one sweep period — a lease that a\n * live pod merely failed to write once is rewritten on the next 10-second heartbeat, so an\n * absence that survives a full period is not a missed write. A VERDICT.\n /\n CORROBORATED_ABSENCE = 'corroborated-absence',\n /\n No establishment marker and no prior observation; THIS run recorded the first one. Not a\n * verdict — the task is left exactly as it stands, and a later run decides.\n /\n FIRST_ABSENCE = 'first-absence',\n /\n Nothing was learned: the observation itself could not be read or recorded. Not a verdict, and\n * unlike {@link FIRST_ABSENCE} it makes no progress toward one — a later run starts over.\n /\n UNDETERMINED = 'undetermined',\n}\n\n/\n May the sweep turn this evidence into a DURABLE terminal status?\n \n Named rather than inlined at the one call site on purpose: this predicate IS the boundary\n * between an enquiry and a verdict, and the sweep is the only consumer allowed to cross it. A\n * second consumer that re-derives the set by hand is how the two come to disagree.\n /\nexport function abandonmentEvidenceIsAVerdict(evidence: A2A_AbandonmentEvidence): boolean {\n return evidence === A2A_AbandonmentEvidence.LEASE_LAPSED \|\| evidence === A2A_AbandonmentEvidence.CORROBORATED_ABSENCE;\n}\n\n/\n An outbound A2A `Task` — the `result` of `tasks/get`, `tasks/cancel`, and of a\n * `message/send` whose turn could not complete inline.\n \n `status.state` is the projection of the persisted `FlowsActors_Status`; `status.timestamp`\n * is when that state was last advanced, so a polling client can tell a fresh `working`\n * from a stale one.\n /\nexport interface A2A_OutboundTask {\n kind: 'task';\n id: string;\n contextId: string;\n status: {\n state: A2A_TaskState;\n timestamp: string;\n /* Present when the state carries an agent-visible message (e.g. why input is required). /\n message?: A2A_OutboundMessage;\n };\n artifacts?: { artifactId: string; name?: string; parts: { kind: string; [k: string]: unknown }[] }[];\n metadata?: Record<string, unknown>;\n}\n\n/* An outbound A2A text message (the `result` of a blocking `message/send`). /\nexport interface A2A_OutboundMessage {\n kind: 'message';\n role: A2A_MessageRole.AGENT;\n parts: { kind: 'text'; text: string }[];\n messageId: string;\n contextId: string;\n metadata?: Record<string, unknown>;\n}\n\n/\n @wildo_source:part:start saas.backend.flows-actors.a2a-agent-card facet:layer:backend facet:family:flows-actors\n \n The A2A discovery contract an external agent fetches at\n * `GET /a2a/.well-known/agent-card.json` to learn what your app exposes over\n * Agent2Agent and how to authenticate. It is SERVED by the engine — you never\n * author it: every ACTOR system with an AGENTIC actor bound to an agent is\n * exposed automatically as one `A2A_Skill` (`skill.id === system.ref`). External\n * agents then POST JSON-RPC `message/send` / `message/stream` to the card `url`.\n * Import path: `@wildo-ai/saas-backend-lib`.\n /\n\n/* One advertised A2A skill = one exposed agentic actor system (`id === system.ref`). /\nexport interface A2A_Skill {\n id: string;\n name: string;\n description: string;\n tags: string[];\n examples?: string[];\n}\n\n/\n The served A2A agent card. `url` is the absolute task-endpoint URI AND the\n * agent's canonical audience: BOTH a USER-delegated and a MACHINE (client-credentials)\n * inbound token MUST carry it as `aud` (RFC 8707 / external-access D7) — a token minted for\n * another surface (including the generic API audience, per the 2026-07-29 flip) is rejected.\n * `securitySchemes.oauth2.flows`\n * advertises BOTH D6 principals — `authorizationCode` (user-delegated → the\n * conversation is owned by the delegating user) and `clientCredentials` (org/app\n * machine → the conversation is owned by the org/app). Tokens are minted by the\n * app's own OIDC provider (`/oauth/authorize`, `/oauth/token`).\n /\n/\n One protocol interface this agent exposes — a URL, a transport, and the version it speaks there.\n \n spec-cite: A2A 1.0 proto `AgentInterface` — `url` (REQUIRED), and \"The version of the A2A\n protocol this interface exposes. Use the latest supported minor version per major version.\n * Examples: `\"0.3\"`, `\"1.0\"`\".\n /\nexport interface A2A_AgentInterface {\n url: string;\n transport: string;\n version: string;\n}\n\nexport interface A2A_AgentCard {\n /*\n The v0.2.5 scalar version field.\n \n KEPT, and deliberately still `0.2.5`. A v0.2.5 client reads only this field, and it is the\n * version that dialect of the surface actually speaks — advertising `1.0` here would tell every\n * legacy client to send `TASK_STATE_` states and `return_immediately`, which is the exact misread\n this migration exists to prevent. 1.0 clients read {@link supportedInterfaces} instead.\n /\n protocolVersion: string;\n /\n Ordered list of supported interfaces, first entry preferred — the 1.0 mechanism for\n * advertising more than one protocol version.\n \n spec-cite: A2A 1.0 proto `AgentCard` — `repeated AgentInterface supported_interfaces = 3\n * [(google.api.field_behavior) = REQUIRED]`, \"Ordered list of supported interfaces. The first\n entry is preferred.\"\n \n * This is what makes serving two dialects a DECLARED capability rather than an undocumented\n * accident: before it, a 1.0 client could only reach the 1.0 vocabulary by guessing that it\n * existed.\n /\n supportedInterfaces: A2A_AgentInterface[];\n name: string;\n description: string;\n url: string;\n version: string;\n capabilities: { streaming: boolean; pushNotifications: boolean };\n defaultInputModes: string[];\n defaultOutputModes: string[];\n skills: A2A_Skill[];\n securitySchemes: Record<string, unknown>;\n security: Record<string, string[]>[];\n}\n/* @wildo_source:part:end saas.backend.flows-actors.a2a-agent-card */\n"]}
1	+ {"version":3,"file":"a2a.backend.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/models/a2a.backend.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { FLOWS_ACTORS_DEFAULT_AGENT_INSTANCE, FlowsActors_Status } from '@wildo-ai/saas-models';\n\n/*\n Backend-local contracts for the inbound Agent2Agent (A2A) JSON-RPC transport.\n * The public card advertises both A2A 1.0 and the legacy 0.2.5 dialect; the\n * controller normalizes both vocabularies onto these canonical message, task,\n * push-notification and agent-card shapes.\n \n Kept backend-local (not `saas-models`) on purpose: no frontend or\n * cross-package consumer owns the A2A wire representation. The conversational\n * runtime remains transport-agnostic; this module owns only the external\n * protocol boundary and the dialect-neutral shapes used by the controller.\n /\n\n/* Legacy scalar version retained for 0.2.5 clients that do not read `supportedInterfaces`. /\nexport const A2A_PROTOCOL_VERSION = '0.2.5';\n\n/\n The transport name for this surface's JSON-RPC binding, as `AgentInterface.transport` spells it.\n \n spec-cite: A2A 1.0 §5.3 — the binding table's JSON-RPC column; the proto's `AgentInterface`\n * carries the transport alongside the url and version.\n /\nexport const A2A_JSONRPC_TRANSPORT = 'JSONRPC';\n\n/* A2A message roles. External callers send `user`; the agent replies as `agent`. /\nexport enum A2A_MessageRole {\n USER = 'user',\n AGENT = 'agent',\n}\n\n/\n A single text part of an A2A message. A2A also defines `file` and `data`\n * parts; this slice consumes/produces TEXT only (the conversational runtime is\n * text-in/markdown-out) and fails closed on a message with no text part.\n /\nexport const A2A_TextPartSchema: z.ZodObject<{\n kind: z.ZodLiteral<'text'>;\n text: z.ZodString;\n}> = z.object({\n kind: z.literal('text'),\n text: z.string(),\n});\n\n/\n An inbound A2A part. Non-text parts are tolerated on the wire (passthrough,\n * unknown-key-preserving) but ignored by the text-only mapping — we never reject\n * a caller for sending a richer part, we just read the text.\n /\nexport const A2A_InboundPartSchema: z.ZodType<Record<string, unknown>> = z.looseObject({\n kind: z.string(),\n});\n\n/* Inbound A2A message (the `params.message` of a `message/send` / `message/stream`). /\nexport const A2A_InboundMessageSchema: z.ZodObject<{\n role: z.ZodOptional<z.ZodEnum<typeof A2A_MessageRole>>;\n parts: z.ZodArray<typeof A2A_InboundPartSchema>;\n messageId: z.ZodOptional<z.ZodString>;\n taskId: z.ZodOptional<z.ZodString>;\n contextId: z.ZodOptional<z.ZodString>;\n metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;\n}> = z.object({\n role: z.enum(A2A_MessageRole).optional(),\n parts: z.array(A2A_InboundPartSchema),\n messageId: z.string().optional(),\n /\n A2A task continuation — \"this message belongs to task X\".\n \n DECLARED AND REJECTED, not declared-and-ignored (review finding A3-9). This transport opens a\n * task per non-inline turn and has no continuation runtime, so honouring the field is a later\n * phase. The two alternatives to rejecting are both worse: dropping it from the schema strips it\n * silently (still reading as supported), and accepting it would open a SECOND task for a message\n * the client explicitly attached to a first — a divergence the client cannot see. The controller\n * therefore answers `INVALID_PARAMS` naming `contextId` as the supported way to continue a thread.\n /\n taskId: z.string().optional(),\n contextId: z.string().optional(),\n metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\n/\n `configuration` of an A2A `message/send` / `message/stream` call.\n \n ## `blocking` is the protocol's field. `returnImmediately` never existed.\n \n ⚠️ An earlier revision keyed the whole task plane on `configuration.returnImmediately`, described\n * as \"the PROTOCOL's own answer to whether this turn is inline\" and supported by quotations\n * attributed to the specification. *The field is not in A2A, and the quotations are not in the\n specification.** v0.2.5 defines `MessageSendConfiguration` as\n * `{ acceptedOutputModes, historyLength?, pushNotificationConfig?, blocking? }`, where `blocking` is\n * documented as \"If the server should treat the client as a blocking request\".\n \n The consequence was not cosmetic: every mechanism built on the trigger — task materialisation,\n * `tasks/get`, `tasks/cancel`, the Redis lease and cancel broadcast, the compare-and-swap, the\n * abandoned-task sweep — was reachable only by a client sending a Wildo-invented field. A\n * conformant client asking for exactly this behaviour with `{\"blocking\": false}` got a blocking\n * call and could never obtain a task id.\n \n The sense is also INVERTED from the field it replaced, so this is not a rename:\n * `returnImmediately: true` ⇒ `blocking: false`.\n \n Absent means blocking. The spec makes the field optional and prescribes no default, so the\n * choice is ours: a client that says nothing keeps the inline `Message` reply, which preserves the\n * hot-path property D-P1-1 exists for (no task row per turn) and changes nothing for existing\n * callers. Only an explicit `blocking: false` opts into a task.\n \n `z.looseObject` on purpose: the configuration carries further fields this transport does not\n * implement yet (`acceptedOutputModes`, `historyLength`, `pushNotificationConfig`), and dropping\n * unknown keys silently would make a future client's request look accepted while its intent was\n * discarded.\n /\nexport const A2A_MessageSendConfigurationSchema: z.ZodType<Record<string, unknown>> = z.looseObject({\n blocking: z.boolean().optional(),\n});\n\n/\n Does this configuration ask for a NON-BLOCKING turn — i.e. a task the client will poll?\n \n The one place the protocol field is interpreted, so the inversion lives here rather than at each\n * call site. `undefined` is deliberately NOT non-blocking; see the schema note above.\n /\nexport function requestsNonBlockingTurn(configuration: unknown): boolean {\n return (configuration as { blocking?: unknown } \| undefined)?.blocking === false;\n}\n\n/* `params` of an A2A `message/send` / `message/stream` call. /\n/\n ⚠️ `looseObject`, and the strict version was a REAL defect — found live, not in review.\n \n A2A 1.0 puts its non-blocking flag at the TOP LEVEL (`return_immediately`), where v0.2.5 nests it\n * under `configuration.blocking`. A strict `z.object` silently STRIPS unknown top-level keys, so\n * `return_immediately` never survived the parse: a 1.0 client's request for a non-blocking turn was\n * discarded, the turn blocked, and the response was a `Message` where the client expected a `Task`.\n * No error anywhere — the client simply looked broken.\n \n The reasoning was already written down TWICE in this very file, on\n * `A2A_MessageSendConfigurationSchema` and `A2A_TaskIdParamsSchema`: \"dropping unknown keys\n silently would make a future client's request look accepted while its intent was discarded.\"\n This schema was the one sibling that did not follow it, and the cost was exactly the one predicted.\n /\nexport const A2A_MessageSendParamsSchema: z.ZodType<{\n message: z.infer<typeof A2A_InboundMessageSchema>;\n configuration?: Record<string, unknown>;\n metadata?: Record<string, unknown>;\n}> = z.looseObject({\n message: A2A_InboundMessageSchema,\n configuration: A2A_MessageSendConfigurationSchema.optional(),\n metadata: z.record(z.string(), z.unknown()).optional(),\n}) as unknown as z.ZodType<{\n message: z.infer<typeof A2A_InboundMessageSchema>;\n configuration?: Record<string, unknown>;\n metadata?: Record<string, unknown>;\n}>;\n\n/\n `params` of an A2A `tasks/get` / `tasks/cancel` call — both address a task by id.\n \n `looseObject` for the same reason the send configuration uses it (review finding L-4): the spec\n * carries further fields here — `historyLength` on `tasks/get` — that this transport does not\n * implement. A strict object DROPS them silently, so the request looks accepted while the client's\n * intent was discarded. Tolerating-and-ignoring is honest; the fields simply have no effect yet.\n \n `id` stays `z.string()`, which is also the NoSQL-operator-injection boundary: an object here\n * would otherwise reach the owner filter as a query operator.\n /\nexport const A2A_TaskIdParamsSchema: z.ZodType<{ id: string; metadata?: Record<string, unknown> }> = z.looseObject({\n id: z.string().min(1),\n metadata: z.record(z.string(), z.unknown()).optional(),\n}) as unknown as z.ZodType<{ id: string; metadata?: Record<string, unknown> }>;\nexport type A2A_TaskIdParams = z.infer<typeof A2A_TaskIdParamsSchema>;\n\n/* JSON-RPC 2.0 request envelope for the A2A endpoint. /\nexport const A2A_JsonRpcRequestSchema: z.ZodObject<{\n jsonrpc: z.ZodLiteral<'2.0'>;\n id: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>;\n method: z.ZodString;\n params: z.ZodOptional<z.ZodUnknown>;\n}> = z.object({\n jsonrpc: z.literal('2.0'),\n id: z.union([z.string(), z.number(), z.null()]),\n method: z.string(),\n params: z.unknown().optional(),\n});\n\nexport type A2A_JsonRpcRequest = z.infer<typeof A2A_JsonRpcRequestSchema>;\nexport type A2A_MessageSendParams = z.infer<typeof A2A_MessageSendParamsSchema>;\n\n/\n JSON-RPC error codes for this transport, split into the two ranges that actually exist.\n \n ## The numbering is SPEC-CONFORMANT, and that was a correction\n \n A2A assigns SIX codes in this block: `-32001` TaskNotFound, `-32002` TaskNotCancelable,\n * `-32003` PushNotificationNotSupported, `-32004` UnsupportedOperation, `-32005`\n * ContentTypeNotSupported, `-32006` InvalidAgentResponse. `-32007`..`-32009` are UNASSIGNED in\n * v0.2.5.\n * spec-cite: A2A v0.2.5 §8.2 (error code assignments)\n \n An earlier revision of this enum occupied five of those slots with Wildo meanings, so a\n * conformant client mis-read every one — an unknown skill answered `-32002`, which the spec defines\n * as TaskNotCancelable, so the client was told the task could not be canceled.\n * spec-cite: N/A — that reading is the MEANING a client derives from the code, not a quotation.\n \n spec-cite: N/A — the sentence quoted just below is this file's OWN retired claim, reproduced so\n * the error is legible; it is not attributed to the specification.\n \n ⚠️ THE COUNT HAS NOW BEEN WRONG TWICE IN THIS BLOCK, which is worth more than the correction.\n * The first note flagged only the `-32001` clash and picked `-32005` without noticing it too was\n * assigned. The SECOND said the spec assigns nine and that \"every slot was taken; there was never a\n * free one to move into\" — and a later pass added a `spec-cite:` marker directly beneath it, so a\n * citation ended up vouching for a number nobody had checked. A citation records WHERE to look; it\n * is not evidence that anyone looked. Re-derive counts from the document, never from this block.\n \n Reserving `-32007`..`-32009` rather than using them is therefore a WILDO CHOICE, not a necessity:\n * they are free today, and leaving them alone keeps the Wildo range from colliding with codes a\n * future A2A version may assign.\n \n The resolution keeps the two ranges apart:\n \n - -32001..-32009 — A2A's, used ONLY with A2A's meanings. Adding a code here means adopting\n * the spec's error for it, never inventing one.\n * - -32010..-32099 — Wildo's. JSON-RPC 2.0 reserves `-32000..-32099` for implementation-defined\n * server errors, and A2A assigns nothing above `-32006`, so this is genuinely free. Wildo\n * concerns that the protocol has no vocabulary for (authentication, skill routing, rate limits,\n * spend caps) live here and cannot collide with a future spec code below `-32010`.\n \n Renumbering was a WIRE change to a shipped surface; it is safe here only because this is a\n * greenfield project, and the e2e assertions that pinned the old literals were moved with it.\n /\nexport enum A2A_JsonRpcErrorCode {\n // ── JSON-RPC 2.0 standard ────────────────────────────────────────────────────────────────\n PARSE_ERROR = -32700,\n INVALID_REQUEST = -32600,\n METHOD_NOT_FOUND = -32601,\n INVALID_PARAMS = -32602,\n INTERNAL_ERROR = -32603,\n\n // ── A2A-assigned (-32001..-32009): the spec's codes, with the spec's meanings ─────────────\n /* A2A `TaskNotFoundError`: the addressed task does not exist, or is not visible to this caller. /\n TASK_NOT_FOUND = -32001,\n /\n A2A `TaskNotCancelableError`: the task is already terminal, so it cannot be canceled.\n \n spec-cite: A2A v0.2.5 §7.4 (tasks/cancel error list, permissive tone) — and N/A for the quoted\n * `\"MUST NOT succeed\"`, which appears here BECAUSE it is false, and for the two client-outcome\n * phrases, which are not document text.\n \n ⚠️ A WILDO DESIGN DECISION, not a protocol requirement — and an earlier revision of this note\n * claimed otherwise by quoting `\"MUST NOT succeed\"` as specification text. *That string is not in\n v0.2.5.** §7.4 is permissive in tone (\"the server will attempt to cancel… but success is not\n * guaranteed\") and lists `TaskNotCancelableError` among its example errors. So the spec PERMITS\n * this answer; it does not mandate it.\n \n spec-cite: N/A — the two phrases below are the OUTCOMES a client could not tell apart, not\n * text from the document.\n \n The reason we choose it stands on its own, which is why the correction changes no behaviour:\n * answering 200 with the task makes \"I stopped it\" and \"it had already finished\"\n * indistinguishable on the wire, and those are different outcomes to anything reconciling state.\n * The task remains readable via `tasks/get` either way.\n /\n TASK_NOT_CANCELABLE = -32002,\n /\n A2A `PushNotificationNotSupportedError`: the agent does not support webhook task updates.\n \n Returned by all four push-notification-configuration operations whenever the agent card\n * advertises `capabilities.pushNotifications: false`. The norm makes this a MUST, and it is not\n * interchangeable with `METHOD_NOT_FOUND`: a client that receives `-32601` cannot distinguish\n * \"this agent does not do push notifications\" from \"this agent is not A2A-compliant\", whereas\n * `-32003` tells it exactly which capability to stop asking for.\n \n spec-cite: A2A 1.0 §3.3.4 — \"If `AgentCard.capabilities.pushNotifications` is `false` or not\n present, operations related to push notification configuration (Create, Get, List, Delete)\n * MUST return `PushNotificationNotSupportedError`\"* — and §5.4, which assigns it the JSON-RPC\n * code `-32003` (gRPC `FAILED_PRECONDITION`, HTTP `400 Bad Request`).\n /\n PUSH_NOTIFICATION_NOT_SUPPORTED = -32003,\n /\n A2A `UnsupportedOperationError`: the agent does not support this operation.\n \n Distinct from `METHOD_NOT_FOUND` in exactly the way `-32003` is: `-32601` says \"this server does\n * not know that method\", which a client cannot tell from a misrouted or non-compliant server, so\n * it retries or reports a transport fault. `-32004` says \"this agent knows the operation and does\n * not offer it\" — permanent, cacheable, actionable.\n \n spec-cite: A2A 1.0 §5.4 assigns `UnsupportedOperationError` the JSON-RPC code `-32004` (gRPC\n * `FAILED_PRECONDITION`, HTTP `400 Bad Request`); §3.3.4 — \"If `AgentCard.capabilities.\n extendedAgentCard` is `false` or not present, attempts to call the Get Extended Agent Card\n * operation MUST return `UnsupportedOperationError`\".\n /\n UNSUPPORTED_OPERATION = -32004,\n\n // ── Wildo-assigned (-32010..-32099): concerns A2A has no vocabulary for ───────────────────\n /** The caller is unauthenticated / the token is invalid. /\n UNAUTHENTICATED = -32010,\n /* The referenced skill / actor system does not exist, or is outside this agent's subset. /\n SKILL_NOT_FOUND = -32011,\n /\n The caller exceeded the per-principal turn rate cap. Ridden by a transport-level HTTP 429 +\n * `Retry-After` (throttling is a transport concern), unlike the codes above which ride HTTP 200\n * per JSON-RPC. The body stays a valid JSON-RPC error so strict clients still parse it.\n /\n RATE_LIMITED = -32012,\n /\n The caller's tenant has exhausted its plan-granted LLM token budget for the current period.\n * Ridden by a transport-level HTTP 402 — deliberately NOT the 429 + `Retry-After` of\n * {@link RATE_LIMITED}: a spend cap is not a rolling-window throttle, so the client's correct\n * reaction is to upgrade the plan or wait for the period to roll, not to retry after N seconds.\n * 402 matches the existing `FEATURE_LIMIT_EXCEEDED` / `INSUFFICIENT_CREDITS` billing mapping.\n /\n BUDGET_EXCEEDED = -32013,\n}\n\n/\n @wildo_source:part:start saas.backend.flows-actors.a2a-task-surface facet:layer:backend facet:family:flows-actors\n \n The A2A TASK surface your app exposes to external agents. You never author these —\n * the engine serves them — but knowing the contract tells you what an agent client can\n * do with a turn your actor system runs.\n \n A task is materialised ONLY when a turn cannot complete inline:\n * - the client sent `configuration.blocking: false` (the A2A field — absent means blocking), or\n * - the turn reached an interrupted state (a human-in-the-loop approval pause).\n \n BOTH triggers are live. The interrupted-state arm needs a runtime that can pause a turn; that\n * is the human-in-the-loop approval gate, and a paused turn now materialises a task carrying\n * `input-required` on all three transports (blocking send, non-blocking send, stream). An earlier\n * revision of this note warned that the arm was inert and `input-required` never emitted — true\n * when written, and left here in corrected form because a reader who remembers the old claim would\n * otherwise conclude the state is decorative and safe to drop.\n \n A blocking turn that answers in one shot returns an A2A `Message` and writes no task\n * row at all. Both shapes are protocol-conformant: the specification types the\n * `message/send` result as `Task \| Message`, so returning either is conformance rather than a\n * shortcut. The inline case is the default so a chatty agent does not accumulate a row per turn.\n * spec-cite: A2A v0.2.5 §7.1 (SendMessageResponse result type)\n \n \n * Once a task exists the client can poll it with `tasks/get` and stop it with\n * `tasks/cancel`. Cancel is a STATUS TRANSITION, never a delete: the spec requires it to\n * return the task's updated state, so a cancelled task stays readable.\n \n ⚠️ What cancel does and does not guarantee. It always records the cancellation, and\n * it aborts the model call for the streaming API transports — which is every agent using\n * the standard text/chat operations. It does NOT interrupt two cases: an agent whose\n * transport buffers its whole reply (a CLI-transport agent, or a non-text operation), and\n * a tool call already in flight — those finish, and only then does the turn stop. So\n * cancel is best read as \"stop as soon as the runtime is able\", not \"stop instantly\".\n * The task record is the truth about the request either way.\n \n Import path: `@wildo-ai/saas-backend-lib`.\n /\n/\n ⚠️ DOCUMENTATION-ONLY. Nothing implements this interface — it exists to give the anchored\n * excerpt a typed shape an app builder can read. The real methods are\n * `A2ATaskBackendService.readTask` / `advanceTask`, whose signatures differ (they take an\n * owner scope). Do not `implements` this; keep it in step with the service by hand, or\n * delete it if it ever drifts.\n /\nexport interface A2A_TaskSurfaceContract {\n /* `tasks/get` — read one task by id. Returns the task in its current state. /\n tasksGet: (taskId: string) => Promise<A2A_OutboundTask \| undefined>;\n /* `tasks/cancel` — request cancellation; returns the task's UPDATED state. /\n tasksCancel: (taskId: string) => Promise<A2A_OutboundTask \| undefined>;\n}\n\n/\n A2A task lifecycle states — the PROTOCOL's closed vocabulary (v0.2.5).\n \n Declared as a named enum rather than inline literals because it is exactly the\n * kind of closed semantic vocabulary that must have one runtime source: the\n * projection from `FlowsActors_Status` reads it, the transport emits it, and tests\n * pin it.\n \n Not every member is emitted by this transport today — `AUTH_REQUIRED` and\n * `REJECTED` have no `FlowsActors_Status` counterpart and are never produced. They\n * are declared because the vocabulary belongs to the protocol, not to us: a client\n * may legitimately receive them from another A2A server, and omitting them would\n * invite a future contributor to invent a second, partial enum.\n /\nexport enum A2A_TaskState {\n /* Acknowledged, not yet processing. /\n SUBMITTED = 'submitted',\n /* Actively being processed. /\n WORKING = 'working',\n /\n Interrupted (non-terminal): the agent needs input. The current transport emits this when a\n * user-delegated turn reaches an approval-gated tool, persists the signed pending decision and\n * materialises an addressable task. Approval or refusal resumes that same execution; machine\n * principals are denied rather than parked because no named person can answer for them.\n /\n INPUT_REQUIRED = 'input-required',\n /* Interrupted (non-terminal): authentication needed. NOT emitted by this transport. /\n AUTH_REQUIRED = 'auth-required',\n /* Terminal: finished successfully. /\n COMPLETED = 'completed',\n /* Terminal: finished with error. /\n FAILED = 'failed',\n /* Terminal: canceled before completion. /\n CANCELED = 'canceled',\n /* Terminal: refused by the agent. NOT emitted by this transport. /\n REJECTED = 'rejected',\n /\n Terminal: the agent cannot determine the task's state.\n \n Declared for the same reason as `AUTH_REQUIRED` and `REJECTED` — the enum's rule is that the\n * protocol vocabulary is represented in full so nobody invents a second, partial one. It was\n * simply missed: the spec defines NINE states and this declared eight (review finding G5-6).\n * Never emitted by this transport, which always knows a task's state or cannot find the row.\n /\n UNKNOWN = 'unknown',\n}\n\n/* States after which no further work occurs — a terminal task cannot be canceled. /\nexport const A2A_TERMINAL_TASK_STATES: ReadonlySet<A2A_TaskState> = new Set([\n A2A_TaskState.COMPLETED,\n A2A_TaskState.FAILED,\n A2A_TaskState.CANCELED,\n A2A_TaskState.REJECTED,\n A2A_TaskState.UNKNOWN,\n]);\n/* @wildo_source:part:end saas.backend.flows-actors.a2a-task-surface /\n\n/\n Deliberately OUTSIDE the `@wildo_source` anchor above: this is an authoring correction for\n * framework maintainers, and the anchored span ships verbatim into application-facing skills\n * where neither the anchor nor this repository's revision history exists.\n \n ⚠️ An earlier revision of the `message/send` paragraph above supported its conclusion with a\n * QUOTATION — \"the agent MAY create a new Task … or MAY return a direct Message response for\n * simple interactions\" — attributed to the A2A specification. It is not in the document.\n * spec-cite: N/A — that sentence is quoted precisely BECAUSE it is absent from A2A v0.2.5; it is\n * the defect, not the standard's words.\n \n The conclusion was right and the authority was invented, and because the block was anchored it\n * shipped that invention into the app-facing skill. Cite the TYPE, which is checkable in one step,\n * not a remembered sentence. See `.claude/rules/external-specification-citations.md`.\n /\n\n/\n Project the engine's persisted lifecycle status onto the A2A protocol vocabulary.\n \n This is the ONLY place the two vocabularies meet, and it is exhaustive by\n * construction — `FlowsActors_Status` is a closed enum, so adding a member without\n * deciding its protocol meaning is a compile error at the `satisfies` below rather\n * than a silent fallthrough to some default state.\n \n Both `READY` and `PENDING` project to `SUBMITTED`: the protocol draws its line at\n * \"acknowledged but not yet processing\", and our two pre-processing states are on the\n * same side of it. `ABORTED` projects to `FAILED` rather than `CANCELED` deliberately —\n * `CANCELED` means a caller asked for it, whereas `ABORTED` is the runtime halting\n * itself (e.g. a tripped circuit breaker), which a client should read as a failure it\n * did not request.\n /\nconst A2A_STATE_BY_FLOWS_ACTORS_STATUS = {\n [FlowsActors_Status.READY]: A2A_TaskState.SUBMITTED,\n [FlowsActors_Status.PENDING]: A2A_TaskState.SUBMITTED,\n [FlowsActors_Status.PROCESSING]: A2A_TaskState.WORKING,\n [FlowsActors_Status.AWAITING_APPROVAL]: A2A_TaskState.INPUT_REQUIRED,\n [FlowsActors_Status.COMPLETED]: A2A_TaskState.COMPLETED,\n [FlowsActors_Status.FAILED]: A2A_TaskState.FAILED,\n [FlowsActors_Status.CANCELLED]: A2A_TaskState.CANCELED,\n [FlowsActors_Status.ABORTED]: A2A_TaskState.FAILED,\n} satisfies Record<FlowsActors_Status, A2A_TaskState>;\n\n/* Project a persisted task status onto its A2A protocol state. /\nexport function toA2ATaskState(status: FlowsActors_Status): A2A_TaskState {\n return A2A_STATE_BY_FLOWS_ACTORS_STATUS[status];\n}\n\n/* True when the persisted status is one the protocol treats as terminal. /\nexport function isTerminalA2ATaskStatus(status: FlowsActors_Status): boolean {\n return A2A_TERMINAL_TASK_STATES.has(toA2ATaskState(status));\n}\n\n/\n The stored instance identity of the DEFAULT (unnamed) A2A agent.\n \n Declared instance refs are constrained to `^[a-z0-9][a-z0-9-]$`, so the `` characters make\n * this value unreachable by any real ref — the default agent gets its own identity on the task\n * plane without a collision, and without the filter having to special-case an absent field.\n /\nexport const A2A_DEFAULT_INSTANCE_REF: string = FLOWS_ACTORS_DEFAULT_AGENT_INSTANCE;\n\n/\n States in which a task is waiting on something OUTSIDE the runtime — a human approval, an\n * authentication step — rather than executing on any pod.\n \n ## Why this is a THIRD class and not a shade of \"non-terminal\" (review finding A3-3)\n \n The liveness design asks one question: \"a pod claimed this work — is that pod still alive?\"\n * That question is only meaningful while a pod is actually executing. Splitting statuses merely\n * into terminal / non-terminal conflates two very different non-terminal situations:\n \n - executing — a pod holds the turn and refreshes a lease. No lease ⇒ the pod died ⇒ the\n * task is abandoned, and reporting the stored `working` forever would be a lie.\n * - interrupted — nobody is executing, deliberately. The lease is released the moment the\n * turn unwinds, so a paused task has no lease BY DESIGN. Applying the abandonment rule here\n * reads a correct pause as a dead pod.\n \n With only the two-way split, a task paused for approval read as `failed` on the very next\n * poll and the sweep then made that durable within the grace window — so the approval seam\n * Phase 1 claims to have prepared would have been destroyed by Phase 1's own liveness rules\n * before Phase 2 could use it. A human approval takes minutes to hours; a lease TTL is 30s.\n \n Deliberately OUTSIDE the `@wildo_source` anchor above: this is engine-internal liveness\n * taxonomy, not app-facing protocol surface, and widening the shipped contract with states this\n * transport cannot yet reach is the mistake finding G2-3 recorded.\n /\nexport const A2A_INTERRUPTED_TASK_STATES: ReadonlySet<A2A_TaskState> = new Set([\n A2A_TaskState.INPUT_REQUIRED,\n A2A_TaskState.AUTH_REQUIRED,\n]);\n\n/\n True when the task's status is one whose truthfulness depends on a pod being alive — i.e.\n * neither terminal nor interrupted.\n \n This is the ONLY predicate that should gate derive-on-read downgrades and the abandoned-task\n * sweep. Using `!isTerminalA2ATaskStatus(...)` for that purpose is the A3-3 defect.\n /\nexport function isLivenessGovernedA2ATaskStatus(status: FlowsActors_Status): boolean {\n const state = toA2ATaskState(status);\n return !A2A_TERMINAL_TASK_STATES.has(state) && !A2A_INTERRUPTED_TASK_STATES.has(state);\n}\n\n/\n The persisted statuses a task may still be advanced FROM — everything non-terminal.\n \n This is the compare-and-swap set for `advanceTask` (finding A3-2). Note it deliberately\n * INCLUDES the interrupted states: a task paused for approval must remain cancellable, and\n * Phase 2 must be able to resume it. \"Cannot be advanced\" means terminal, nothing else.\n /\nexport const ADVANCEABLE_TASK_STATUSES: FlowsActors_Status[] =\n (Object.values(FlowsActors_Status) as FlowsActors_Status[]).filter((status) => !isTerminalA2ATaskStatus(status));\n\n/\n The persisted statuses whose stored value is only trustworthy while a pod is alive — the\n * candidate set for the abandoned-task sweep and for the derive-on-read downgrade.\n \n Strictly NARROWER than {@link ADVANCEABLE_TASK_STATUSES}: an interrupted task is advanceable\n * but is not abandoned merely because no pod holds it. Both are derived from the single status\n * projection above, so a new `FlowsActors_Status` member lands in the right set automatically\n * once its protocol meaning is decided.\n /\nexport const LIVENESS_GOVERNED_TASK_STATUSES: FlowsActors_Status[] =\n (Object.values(FlowsActors_Status) as FlowsActors_Status[]).filter(isLivenessGovernedA2ATaskStatus);\n\n/\n WHY an absent lease is absent — the difference between a VERDICT and a failed enquiry.\n \n ## The inversion this vocabulary exists to name (review finding S-1a)\n \n \"No lease\" was a single answer with two incompatible meanings, and the sweep read both as\n * death:\n \n - a pod held this task and stopped refreshing — the lease existed and lapsed. That is\n * abandonment, and repairing the row is the sweep's whole purpose.\n * - this task's liveness was never observable at all — the owning pod could not write the\n * lease (its own Redis connection is broken while the sweep's is fine, or it started the turn\n * with no client at all). The turn is HEALTHY and running; nothing about it is knowable from\n * the lease.\n \n The two are indistinguishable from a single read of one key, so the write side leaves a second,\n * long-lived ESTABLISHMENT marker whenever it successfully writes a lease. Its presence is what\n * turns an absent lease into evidence; its absence is what makes the reading indeterminate.\n \n `isLeaseMechanismWritable` does NOT cover this: it is evaluated on the SWEEP's pod, so a\n * per-pod outage on the executing pod passes it unnoticed. That check answers \"can the fleet's\n * liveness signal be trusted at all\"; this answers \"does this one task's missing lease mean\n * anything\".\n \n Four members, not two, because \"do not act\" has two causes that want opposite follow-ups: one\n * makes progress toward a verdict on a later run, the other learned nothing at all and must not\n * be recorded as though it had. Merging them is the semantic collapse this framework refuses.\n /\nexport enum A2A_AbandonmentEvidence {\n /\n The task's lease was demonstrably established and has since lapsed. A pod claimed this work\n * and stopped refreshing — the classic dead-pod signature, and a VERDICT.\n /\n LEASE_LAPSED = 'lease-lapsed',\n /\n No establishment marker, but a PRIOR sweep run recorded the same absence and that observation\n * is still standing. Two observations separated by at least one sweep period — a lease that a\n * live pod merely failed to write once is rewritten on the next 10-second heartbeat, so an\n * absence that survives a full period is not a missed write. A VERDICT.\n /\n CORROBORATED_ABSENCE = 'corroborated-absence',\n /\n No establishment marker and no prior observation; THIS run recorded the first one. Not a\n * verdict — the task is left exactly as it stands, and a later run decides.\n /\n FIRST_ABSENCE = 'first-absence',\n /\n Nothing was learned: the observation itself could not be read or recorded. Not a verdict, and\n * unlike {@link FIRST_ABSENCE} it makes no progress toward one — a later run starts over.\n /\n UNDETERMINED = 'undetermined',\n}\n\n/\n May the sweep turn this evidence into a DURABLE terminal status?\n \n Named rather than inlined at the one call site on purpose: this predicate IS the boundary\n * between an enquiry and a verdict, and the sweep is the only consumer allowed to cross it. A\n * second consumer that re-derives the set by hand is how the two come to disagree.\n /\nexport function abandonmentEvidenceIsAVerdict(evidence: A2A_AbandonmentEvidence): boolean {\n return evidence === A2A_AbandonmentEvidence.LEASE_LAPSED \|\| evidence === A2A_AbandonmentEvidence.CORROBORATED_ABSENCE;\n}\n\n/\n An outbound A2A `Task` — the `result` of `tasks/get`, `tasks/cancel`, and of a\n * `message/send` whose turn could not complete inline.\n \n `status.state` is the projection of the persisted `FlowsActors_Status`; `status.timestamp`\n * is when that state was last advanced, so a polling client can tell a fresh `working`\n * from a stale one.\n /\nexport interface A2A_OutboundTask {\n kind: 'task';\n id: string;\n contextId: string;\n status: {\n state: A2A_TaskState;\n timestamp: string;\n /* Present when the state carries an agent-visible message (e.g. why input is required). /\n message?: A2A_OutboundMessage;\n };\n artifacts?: { artifactId: string; name?: string; parts: { kind: string; [k: string]: unknown }[] }[];\n metadata?: Record<string, unknown>;\n}\n\n/* An outbound A2A text message (the `result` of a blocking `message/send`). /\nexport interface A2A_OutboundMessage {\n kind: 'message';\n role: A2A_MessageRole.AGENT;\n parts: { kind: 'text'; text: string }[];\n messageId: string;\n contextId: string;\n metadata?: Record<string, unknown>;\n}\n\n/\n @wildo_source:part:start saas.backend.flows-actors.a2a-agent-card facet:layer:backend facet:family:flows-actors\n \n The A2A discovery contract an external agent fetches at\n * `GET /a2a/.well-known/agent-card.json` to learn what your app exposes over\n * Agent2Agent and how to authenticate. It is SERVED by the engine — you never\n * author it: every ACTOR system with an AGENTIC actor bound to an agent is\n * exposed automatically as one `A2A_Skill` (`skill.id === system.ref`). External\n * agents then POST JSON-RPC `message/send` / `message/stream` to the card `url`.\n * Import path: `@wildo-ai/saas-backend-lib`.\n /\n\n/* One advertised A2A skill = one exposed agentic actor system (`id === system.ref`). /\nexport interface A2A_Skill {\n id: string;\n name: string;\n description: string;\n tags: string[];\n examples?: string[];\n}\n\n/\n The served A2A agent card. `url` is the absolute task-endpoint URI AND the\n * agent's canonical audience: BOTH a USER-delegated and a MACHINE (client-credentials)\n * inbound token MUST carry it as `aud` (RFC 8707 / external-access D7) — a token minted for\n * another surface (including the generic API audience, per the 2026-07-29 flip) is rejected.\n * `securitySchemes.oauth2.flows`\n * advertises BOTH D6 principals — `authorizationCode` (user-delegated → the\n * conversation is owned by the delegating user) and `clientCredentials` (org/app\n * machine → the conversation is owned by the org/app). Tokens are minted by the\n * app's own OIDC provider (`/oauth/authorize`, `/oauth/token`).\n /\n/\n One protocol interface this agent exposes — a URL, a transport, and the version it speaks there.\n \n spec-cite: A2A 1.0 proto `AgentInterface` — `url` (REQUIRED), and \"The version of the A2A\n protocol this interface exposes. Use the latest supported minor version per major version.\n * Examples: `\"0.3\"`, `\"1.0\"`\".\n /\nexport interface A2A_AgentInterface {\n url: string;\n transport: string;\n version: string;\n}\n\nexport interface A2A_AgentCard {\n /*\n The v0.2.5 scalar version field.\n \n KEPT, and deliberately still `0.2.5`. A v0.2.5 client reads only this field, and it is the\n * version that dialect of the surface actually speaks — advertising `1.0` here would tell every\n * legacy client to send `TASK_STATE_` states and `return_immediately`, which is the exact misread\n this migration exists to prevent. 1.0 clients read {@link supportedInterfaces} instead.\n /\n protocolVersion: string;\n /\n Ordered list of supported interfaces, first entry preferred — the 1.0 mechanism for\n * advertising more than one protocol version.\n \n spec-cite: A2A 1.0 proto `AgentCard` — `repeated AgentInterface supported_interfaces = 3\n * [(google.api.field_behavior) = REQUIRED]`, \"Ordered list of supported interfaces. The first\n entry is preferred.\"\n \n * This is what makes serving two dialects a DECLARED capability rather than an undocumented\n * accident: before it, a 1.0 client could only reach the 1.0 vocabulary by guessing that it\n * existed.\n /\n supportedInterfaces: A2A_AgentInterface[];\n name: string;\n description: string;\n url: string;\n version: string;\n capabilities: { streaming: boolean; pushNotifications: boolean };\n defaultInputModes: string[];\n defaultOutputModes: string[];\n skills: A2A_Skill[];\n securitySchemes: Record<string, unknown>;\n security: Record<string, string[]>[];\n}\n/* @wildo_source:part:end saas.backend.flows-actors.a2a-agent-card */\n"]}

package/dist/esm/flows-actors/a2a/services/a2a-push-delivery-log.repository.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a-push-delivery-log.repository.d.ts","sourceRoot":"","sources":["~~../../../../../../~~src/flows-actors/a2a/services/a2a-push-delivery-log.repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,OAAO,EAGL,KAAK,sBAAsB,EAE5B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iFAAiF,CAAC;AAClI,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mFAAmF,CAAC;AA6BlI,+FAA+F;AAC/F,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,sBAAsB,EACtB,YAAY,GAAG,QAAQ,GAAG,0BAA0B,GAAG,2BAA2B,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAC3H,GAAG,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAKjE,qBACa,4BAA4B;IAIF,OAAO,CAAC,QAAQ,CAAC,MAAM;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+D;gBAGlC,MAAM,EAAE,aAAa,EACR,YAAY,EAAE,0BAA0B;IAM3G;;;;;;;;;;OAUG;IACU,IAAI,CACf,KAAK,EAAE,wBAAwB,EAC/B,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAgB9C,4FAA4F;IAC/E,IAAI,CACf,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC;IAUzC;;;;;;;;OAQG;IACU,YAAY,CACvB,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC;IAQnB,wBAAwB;IACX,aAAa,CACxB,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;IAQnB,iFAAiF;IACpE,iBAAiB,CAC5B,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,IAAI,EACnB,OAAO,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC1E,OAAO,CAAC,OAAO,CAAC;IAQnB,sEAAsE;IACzD,iBAAiB,CAC5B,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC1E,OAAO,CAAC,OAAO,CAAC;IAQnB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAQtB,mGAAmG;YACrF,UAAU;CAiBzB"}
1	+ {"version":3,"file":"a2a-push-delivery-log.repository.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/services/a2a-push-delivery-log.repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,OAAO,EAGL,KAAK,sBAAsB,EAE5B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iFAAiF,CAAC;AAClI,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mFAAmF,CAAC;AA6BlI,+FAA+F;AAC/F,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,sBAAsB,EACtB,YAAY,GAAG,QAAQ,GAAG,0BAA0B,GAAG,2BAA2B,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAC3H,GAAG,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAKjE,qBACa,4BAA4B;IAIF,OAAO,CAAC,QAAQ,CAAC,MAAM;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+D;gBAGlC,MAAM,EAAE,aAAa,EACR,YAAY,EAAE,0BAA0B;IAM3G;;;;;;;;;;OAUG;IACU,IAAI,CACf,KAAK,EAAE,wBAAwB,EAC/B,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAgB9C,4FAA4F;IAC/E,IAAI,CACf,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC;IAUzC;;;;;;;;OAQG;IACU,YAAY,CACvB,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC;IAQnB,wBAAwB;IACX,aAAa,CACxB,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;IAQnB,iFAAiF;IACpE,iBAAiB,CAC5B,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,IAAI,EACnB,OAAO,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC1E,OAAO,CAAC,OAAO,CAAC;IAQnB,sEAAsE;IACzD,iBAAiB,CAC5B,KAAK,EAAE,wBAAwB,EAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC1E,OAAO,CAAC,OAAO,CAAC;IAQnB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAQtB,mGAAmG;YACrF,UAAU;CAiBzB"}

package/dist/esm/flows-actors/a2a/services/a2a-push-dispatcher.backend.service.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a-push-dispatcher.backend.service.d.ts","sourceRoot":"","sources":["~~../../../../../../~~src/flows-actors/a2a/services/a2a-push-dispatcher.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAG1F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mFAAmF,CAAC;AAClI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAItE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,wBAAwB,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBACa,+BAA+B;IAIL,OAAO,CAAC,QAAQ,CAAC,MAAM;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW;IALvF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+D;gBAGlC,MAAM,EAAE,aAAa,EACR,YAAY,EAAE,mBAAmB,EACxB,WAAW,EAAE,4BAA4B;IAMrH;;;;;;;;;OASG;IACU,kBAAkB,CAC7B,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,gBAAgB,EACtB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,yBAAyB,EAAE,MAAM,EACjC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,OAAO,CAAC,IAAI,CAAC;CAyDjB"}
1	+ {"version":3,"file":"a2a-push-dispatcher.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/services/a2a-push-dispatcher.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAG1F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mFAAmF,CAAC;AAClI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAItE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,wBAAwB,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBACa,+BAA+B;IAIL,OAAO,CAAC,QAAQ,CAAC,MAAM;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW;IALvF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+D;gBAGlC,MAAM,EAAE,aAAa,EACR,YAAY,EAAE,mBAAmB,EACxB,WAAW,EAAE,4BAA4B;IAMrH;;;;;;;;;OASG;IACU,kBAAkB,CAC7B,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,gBAAgB,EACtB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,yBAAyB,EAAE,MAAM,EACjC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,OAAO,CAAC,IAAI,CAAC;CAyDjB"}

package/dist/esm/flows-actors/a2a/services/a2a-task-cancellation.backend.service.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a-task-cancellation.backend.service.d.ts","sourceRoot":"","sources":["~~../../../../../../~~src/flows-actors/a2a/services/a2a-task-cancellation.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AAExF,OAAO,EAAE,uBAAuB,EAAE,MAAM,gEAAgE,CAAC;AAsBzG;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,sCAAsC,QAAc,CAAC;AAElE;;;;;;;;GAQG;AACH,eAAO,MAAM,wCAAwC,QAAc,CAAC;AAEpE,qBACa,iCAAiC;IAUP,OAAO,CAAC,QAAQ,CAAC,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAVxE,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IACjE,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;IAEjE,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,gBAAgB,CAAS;gBAGqB,MAAM,EAAE,aAAa,EACf,YAAY,EAAE,YAAY;IAGtF,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;OAUG;YACW,gBAAgB;IA2C9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;IACU,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAgG5D;;;;;;;;;;;;;OAaG;IACU,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAenD;;;;;;;;OAQG;IACU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkB5D;;;;;;;;;;OAUG;IACU,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACU,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA2BrF;;;;;;;;;;;;;;;;OAgBG;IACU,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC;CAY1D"}
1	+ {"version":3,"file":"a2a-task-cancellation.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/services/a2a-task-cancellation.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AAExF,OAAO,EAAE,uBAAuB,EAAE,MAAM,gEAAgE,CAAC;AAsBzG;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,sCAAsC,QAAc,CAAC;AAElE;;;;;;;;GAQG;AACH,eAAO,MAAM,wCAAwC,QAAc,CAAC;AAEpE,qBACa,iCAAiC;IAUP,OAAO,CAAC,QAAQ,CAAC,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAVxE,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IACjE,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;IAEjE,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,gBAAgB,CAAS;gBAGqB,MAAM,EAAE,aAAa,EACf,YAAY,EAAE,YAAY;IAGtF,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;OAUG;YACW,gBAAgB;IA2C9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;IACU,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAgG5D;;;;;;;;;;;;;OAaG;IACU,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAenD;;;;;;;;OAQG;IACU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkB5D;;;;;;;;;;OAUG;IACU,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACU,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA2BrF;;;;;;;;;;;;;;;;OAgBG;IACU,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC;CAY1D"}

package/dist/esm/flows-actors/a2a/services/a2a-task-cancellation.backend.service.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a-task-cancellation.backend.service.js","sourceRoot":"","sources":["../../../../../../src/flows-actors/a2a/services/a2a-task-cancellation.backend.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n Cross-pod A2A task cancellation.\n \n ## You do not need to find the executing pod\n \n With several backend replicas behind a load balancer, a `tasks/cancel` request\n * almost never lands on the pod that is running that task's LLM turn. The obvious\n * design — discover which pod owns it and route there — needs a pod registry, a\n * liveness view of it, and an internal call path, and it is wrong on every one of\n * those axes when a pod restarts mid-turn.\n \n Instead this BROADCASTS. Any pod publishes `{taskId}` to one Redis channel; every\n * pod runs a single shared subscriber; only the pod holding that `taskId` in its\n * in-process registry reacts. One connection per pod, no routing table, and a pod\n * that died simply does not answer — which is the correct behaviour, not an error to\n * handle.\n \n Rejected alternative: polling a Redis flag inside the token loop. That puts a GET on\n * the hottest path in the system (per N tokens, per concurrent turn) and bounds\n * cancellation latency by token cadence. Pub/sub costs nothing per token.\n \n ## Liveness is the same mechanism's other half\n \n While a pod owns a turn it refreshes a TTL'd lease key. That is what lets\n * `tasks/get` report an abandoned task honestly instead of leaving it `working`\n * forever after a pod dies — see the lease helpers below.\n \n An absent lease is NOT self-explanatory, though, and reading it as death is an inversion that\n * costs real work: a pod that could not write the lease looks exactly like a pod that died. So\n * every successful lease write also leaves a long-lived ESTABLISHMENT marker, and\n * `corroborateAbandonment` is what turns \"no lease\" into either a verdict or an admission that\n * nothing was learned. Only the sweep — the one consumer that makes a liveness answer DURABLE —\n * asks that question.\n /\n\nimport { inject, injectable } from 'inversify';\nimport type { RedisClientType } from 'redis';\n\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport type { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\nimport type { RedisService } from '~wildo-backend-lib/databases/services/redis.service';\nimport { projectCaughtErrorLogFields } from '~wildo-backend-lib/errors/utils/error-log-level-classification.backend.utils';\nimport { A2A_AbandonmentEvidence } from '~wildo-backend-lib/flows-actors/a2a/models/a2a.backend.schemas';\n\n/* Channel every replica subscribes to. App-prefixed so tenants of one Redis never cross. /\nconst CANCEL_CHANNEL_SUFFIX = 'a2a:task:cancel';\n/* Lease key prefix — presence means \"a live pod is working this task right now\". /\nconst LEASE_KEY_PREFIX = 'a2a:task:lease:';\n/\n ESTABLISHMENT marker prefix — presence means \"this task's liveness WAS observable at some point\n * recently\", which is a different fact from \"it is alive now\" and has a different lifetime.\n \n It is what makes an absent lease MEAN something (see {@link A2A_AbandonmentEvidence}). Written\n * by the same code path and in the same failure domain as the lease itself, so it can only exist\n * if a write actually succeeded — which is exactly the property being recorded.\n /\nconst LEASE_ESTABLISHED_KEY_PREFIX = 'a2a:task:leased-once:';\n/\n The sweep's own note that it has already seen one unexplained absence for a task. Written by the\n * SWEEP's pod, whose write capability `isLeaseMechanismWritable` proved moments earlier — so the\n * medium is known-good at the point of use, unlike the lease itself.\n /\nconst ABANDONMENT_OBSERVATION_KEY_PREFIX = 'a2a:task:absence-seen:';\n\n/\n Lease TTL and refresh cadence. The refresh interval is deliberately well under the\n * TTL: a single missed refresh (GC pause, a slow Redis round-trip) must not make a\n * healthy turn look abandoned. Only a genuinely dead pod stops refreshing.\n /\nexport const A2A_TASK_LEASE_TTL_SECONDS = 30;\nexport const A2A_TASK_LEASE_REFRESH_MS = 10_000;\n\n/\n How long the establishment marker outlives its last refresh.\n \n Sized to comfortably span the sweep's grace window plus its hourly period, so a pod that dies\n * mid-turn is still recognisable as HAVING held the task when the next sweep looks. It is a\n * timing optimisation, never a correctness requirement: if it lapses, the reading degrades to\n * {@link A2A_AbandonmentEvidence.FIRST_ABSENCE} and the row is repaired one run later instead of\n * on the first — which is the direction this whole mechanism errs in anyway.\n /\nexport const A2A_TASK_LEASE_ESTABLISHED_TTL_SECONDS = 6 60 * 60;\n\n/*\n How long one unexplained absence stands as corroboration for the next run.\n \n MUST exceed the sweep's period or no observation ever survives to be corroborated and nothing\n * is ever repaired through that path; generous beyond it so a skipped run (the fleet-wide abstain)\n * does not reset the count. Nothing clears it on recovery, and it does not need clearing: a task\n * whose pod recovered answers ALIVE on the lease long before this is consulted, and once its lease\n * lapses for real the establishment marker gives the verdict directly.\n /\nexport const A2A_TASK_ABSENCE_OBSERVATION_TTL_SECONDS = 3 60 * 60;\n\n@injectable()\nexport class A2ATaskCancellationBackendService {\n /** Tasks this pod is currently executing → the controller that aborts them. /\n private readonly localTurns = new Map<string, AbortController>();\n /* Lease heartbeats keyed by task id, cleared on release. /\n private readonly leaseTimers = new Map<string, NodeJS.Timeout>();\n\n private subscriber: RedisClientType \| null = null;\n private subscribeStarted = false;\n\n constructor(\n @inject(SAAS_SERVICE_TYPES.Logger) private readonly logger: LoggerService,\n @inject(SAAS_SERVICE_TYPES.RedisService) private readonly redisService: RedisService,\n ) {}\n\n private channel(): string {\n return `${this.redisService.getAppPrefix()}${CANCEL_CHANNEL_SUFFIX}`;\n }\n\n private leaseKey(taskId: string): string {\n return `${LEASE_KEY_PREFIX}${taskId}`;\n }\n\n private leaseEstablishedKey(taskId: string): string {\n return `${LEASE_ESTABLISHED_KEY_PREFIX}${taskId}`;\n }\n\n private absenceObservationKey(taskId: string): string {\n return `${ABANDONMENT_OBSERVATION_KEY_PREFIX}${taskId}`;\n }\n\n /\n Start this pod's single shared subscriber. Idempotent — safe to call from every\n * turn, so no startup ordering is required.\n \n `node-redis` forbids commands on a subscribed connection, so the subscriber MUST be\n * a duplicate rather than the shared client. Same pattern the WebSocket adapter uses.\n \n Fails OPEN by design: if Redis is unreachable the turn still runs — losing the\n * ability to cancel is strictly better than refusing to answer at all. The failure is\n * logged at ERROR because a persistent one silently disables cancellation fleet-wide.\n /\n private async ensureSubscriber(): Promise<void> {\n if (this.subscribeStarted) return;\n this.subscribeStarted = true;\n\n const client = this.redisService.getReadyClient();\n if (!client) {\n this.logger.error('[A2ATaskCancel] Redis unavailable — cross-pod cancellation is DISABLED for this pod');\n return;\n }\n\n let subscriber: RedisClientType \| undefined;\n try {\n subscriber = client.duplicate() as RedisClientType;\n subscriber.on('error', (error: unknown) => {\n this.logger.error('[A2ATaskCancel] Cancel-channel subscriber error', { ...projectCaughtErrorLogFields(error) });\n });\n // REARM on a later death (review finding L-2). `subscribeStarted` was reset only inside the\n // SETUP catch, so a subscriber that connected and then dropped — a Redis restart, a failover,\n // an idle-timeout reap — logged from the handler above and was never rebuilt for the rest of\n // the pod's lifetime. Cross-pod cancellation then silently stopped working on that pod while\n // every other signal still looked healthy: the turns run, the leases refresh, and only the\n // broadcast never arrives. Clearing the latch lets the next turn rebuild it.\n subscriber.on('end', () => {\n this.logger.warn('[A2ATaskCancel] Cancel-channel subscriber closed; re-arming so the next turn rebuilds it');\n this.subscriber = undefined;\n this.subscribeStarted = false;\n });\n await subscriber.connect();\n await subscriber.subscribe(this.channel(), (message: string) => this.onCancelBroadcast(message));\n this.subscriber = subscriber;\n } catch (error) {\n // DESTROY the half-built connection before retrying. `connect()` can succeed and\n // `subscribe()` still throw, which leaves a live, unusable socket; since\n // `subscribeStarted` resets to allow a retry, every later turn would open another one\n // and leak a Redis connection per turn until the pod hit its file-descriptor limit.\n if (subscriber) {\n try { await subscriber.destroy(); } catch { / already dead — nothing to reclaim / }\n }\n this.subscribeStarted = false; // allow a later turn to retry\n this.logger.error('[A2ATaskCancel] Failed to subscribe to the cancel channel', { ...projectCaughtErrorLogFields(error) });\n }\n }\n\n /\n Handle a broadcast. Every pod receives every cancel; only the owner acts, and a pod\n * that does not own the task does nothing at all — that silence is the design, not a\n * missed message.\n /\n private onCancelBroadcast(taskId: string): void {\n const controller = this.localTurns.get(taskId);\n if (!controller) return;\n this.logger.info('[A2ATaskCancel] Aborting a locally-executing turn on broadcast', { taskId });\n controller.abort();\n }\n\n /\n Register a turn as executing on this pod: returns the signal to hand to the model\n * call, and starts the liveness lease.\n /\n public async beginTurn(taskId: string): Promise<AbortSignal> {\n // ORDER IS LOAD-BEARING. Register locally and write the lease BEFORE the subscriber\n // setup, which on the first turn performs a full Redis duplicate + connect + subscribe.\n // Awaiting that first would leave a window in which the task is materialised and the\n // client — which asked for a non-blocking turn precisely so it could poll at once — sees\n // a non-terminal task with no lease and is told FAILED by derive-on-read.\n const controller = new AbortController();\n this.localTurns.set(taskId, controller);\n\n let leaseEverWritten = false;\n let unwritableAlreadyReported = false;\n const refresh = async (): Promise<void> => {\n try {\n await this.redisService.set(this.leaseKey(taskId), '1', { ttl: A2A_TASK_LEASE_TTL_SECONDS });\n // The ESTABLISHMENT marker rides the same write, in the same failure domain, and is what\n // makes a LATER absence of the lease mean something: a reader that finds no lease but\n // finds this knows a pod really did hold the task and stopped, rather than that this\n // task's liveness was never observable at all. Written every refresh so a long turn keeps\n // it alive; deliberately NOT written before the lease, so it can never claim an\n // establishment that did not happen.\n await this.redisService.set(this.leaseEstablishedKey(taskId), '1', { ttl: A2A_TASK_LEASE_ESTABLISHED_TTL_SECONDS });\n leaseEverWritten = true;\n } catch (error) {\n // A missed REFRESH is survivable — the TTL is several refreshes long, so the lease\n // written earlier still answers for this turn.\n //\n // A lease that was NEVER successfully written is a different thing entirely (review\n // finding A3-4), and it used to log identically. No other pod can distinguish \"the\n // write failed\" from \"the pod died\": `tasks/get` on any other replica reports this\n // healthy running turn as FAILED, and the sweep then makes that answer DURABLE. This\n // is the write-side twin of the read-side hole G2-8 closed — the JSDoc claim that\n // \"only a genuinely dead pod stops refreshing\" was false in exactly this case.\n if (leaseEverWritten) {\n this.logger.warn('[A2ATaskCancel] Lease refresh failed', { taskId, ...projectCaughtErrorLogFields(error) });\n return;\n }\n // ONCE per turn, not once per heartbeat. The heartbeat now runs even with no Redis at all\n // (see below), so an unconditional log here would emit a line every 10 seconds for every\n // concurrent turn of a Redis-less deployment — which is how a channel that carries a real\n // signal gets tuned out.\n if (unwritableAlreadyReported) return;\n unwritableAlreadyReported = true;\n // The two causes are logged at DIFFERENT levels because one is a configuration and the\n // other is a fault. No client on this pod is the supported single-replica / local-dev\n // shape: `isTurnAlive` fails safe toward \"alive\" there and nothing reads liveness across\n // pods, so it is a WARN. A client that is present and REJECTED the write is the dangerous\n // asymmetry — this pod is partitioned from a liveness plane every other replica can still\n // read — and it keeps the ERROR level it had.\n if (!this.redisService.getReadyClient()) {\n this.logger.warn('[A2ATaskCancel] No Redis on this pod; this turn has no liveness lease and cannot be cancelled from another replica', {\n taskId,\n consequence: 'harmless on a single replica; on a fleet, other pods cannot observe this turn until Redis returns',\n ...projectCaughtErrorLogFields(error),\n });\n return;\n }\n this.logger.error('[A2ATaskCancel] Task lease has NEVER been written; other pods will read this live turn as abandoned', {\n taskId,\n consequence: 'tasks/get on another replica reports failed until a later refresh lands; the sweep now abstains rather than recording it durably',\n ...projectCaughtErrorLogFields(error),\n });\n }\n };\n await refresh();\n // Clear any prior heartbeat for this id before replacing it. Unreachable today\n // (task ids are freshly minted uuids), but an overwritten `setInterval` handle is\n // unclearable — it would refresh a lease forever and keep a dead task looking alive.\n const existing = this.leaseTimers.get(taskId);\n if (existing) clearInterval(existing);\n\n // ── The heartbeat is installed UNCONDITIONALLY, and that is a fix, not a tidy-up ──────────\n //\n // This whole block used to sit behind `if (this.redisService.getReadyClient())`, so a turn\n // that began while this pod's client was not ready got NO lease and NO retry — it stayed\n // unobservable for its entire life even after Redis came back, and nothing was logged at all,\n // because the failing write never even ran. That is the SILENT half of the inversion the\n // never-written branch above documents, and it is strictly worse: a failed first write\n // self-heals on the next 10-second refresh, an absent heartbeat never does.\n //\n // The cost in a genuinely Redis-less deployment is one unref'd timer per in-flight turn and a\n // caught rejection every 10 seconds; the log is emitted once (above), and `redisService.set`\n // builds its error without logging. That is cheap enough to buy automatic recovery.\n const timer = setInterval(() => { void refresh(); }, A2A_TASK_LEASE_REFRESH_MS);\n // Never hold the event loop open on a heartbeat — a draining pod must still exit.\n timer.unref?.();\n this.leaseTimers.set(taskId, timer);\n\n // Subscriber setup happens AFTER the lease exists (see the note above). Not awaited:\n // a slow Redis handshake must not delay the turn, and a cancel arriving before the\n // subscription is live is already handled — `requestCancel` aborts a locally-owned turn\n // directly, without a round-trip.\n void this.ensureSubscriber();\n\n return controller.signal;\n }\n\n /\n Release a finished turn: stop the heartbeat, drop the lease, forget the controller.\n \n Dropping the lease EAGERLY matters — a terminal task with a live lease would look\n * like it is still executing to anything reading liveness.\n \n The ESTABLISHMENT marker is deliberately NOT dropped with it. The two record different kinds\n * of fact: the lease says \"a pod is working this NOW\" and stops being true the instant the turn\n * unwinds, while the marker says \"this task's liveness was observable\", which stays true\n * afterwards. Keeping it also covers the one case that would otherwise regress — a turn that\n * finished but whose terminal write did not land — since the row is then genuinely abandoned and\n * the sweep can say so on its first pass instead of waiting for corroboration. It expires on its\n * own TTL, so nothing accumulates.\n /\n public async endTurn(taskId: string): Promise<void> {\n const timer = this.leaseTimers.get(taskId);\n if (timer) {\n clearInterval(timer);\n this.leaseTimers.delete(taskId);\n }\n this.localTurns.delete(taskId);\n try {\n await this.redisService.del(this.leaseKey(taskId));\n } catch (error) {\n // The TTL reaps it anyway; this only shortens the window.\n this.logger.warn('[A2ATaskCancel] Failed to drop a task lease', { taskId, ...projectCaughtErrorLogFields(error) });\n }\n }\n\n /\n Ask the fleet to cancel a task.\n \n Returns whether the request was BROADCAST, never whether it was honoured: the owning\n * pod may be gone, or the turn may already have finished. The caller must therefore\n * treat the task record — not this return value — as the truth about cancellation,\n * which is also what the A2A spec requires (`tasks/cancel` returns the task's updated\n * state, not an acknowledgement).\n /\n public async requestCancel(taskId: string): Promise<boolean> {\n // A turn owned by THIS pod is aborted directly — no round-trip, and it still works\n // when Redis is down, which is the single-replica and local-dev case.\n const local = this.localTurns.get(taskId);\n if (local) local.abort();\n\n const client = this.redisService.getReadyClient();\n if (!client) return Boolean(local);\n\n try {\n await client.publish(this.channel(), taskId);\n return true;\n } catch (error) {\n this.logger.error('[A2ATaskCancel] Failed to broadcast a cancel', { taskId, ...projectCaughtErrorLogFields(error) });\n return Boolean(local);\n }\n }\n\n /\n Is some pod still working this task?\n \n This is the read half of the liveness design: a task whose stored status is\n * non-terminal but whose lease has expired was abandoned by a pod that died, and must\n * be reported as failed rather than left reading `working` forever.\n \n Fails SAFE toward \"alive\" when Redis is unreachable — reporting a healthy task as\n * abandoned because the cache blipped would be a far worse lie than a brief stale\n * `working`.\n /\n public async isTurnAlive(taskId: string): Promise<boolean> {\n if (this.localTurns.has(taskId)) return true;\n // Redis ABSENT is not evidence of death. `RedisService.exists` RETURNS FALSE when there\n // is no client rather than throwing, so the catch below never fired for that case and the\n // documented \"fails safe toward alive\" was untrue: with Redis down, every task on another\n // pod would have been reported FAILED. Check the client explicitly.\n if (!this.redisService.getReadyClient()) return true;\n try {\n return await this.redisService.exists(this.leaseKey(taskId));\n } catch {\n return true;\n }\n }\n\n /\n WHY is this task's lease absent — and may that absence be turned into a durable verdict?\n \n Asked by the abandoned-task sweep, and only by it, AFTER {@link isTurnAlive} has already\n * answered \"no lease\". `isTurnAlive` returns a boolean because every other consumer only needs\n * to know whether to keep waiting; the sweep is the one caller that writes a TERMINAL status,\n * so it is the one caller that must be able to tell a verdict from a failed enquiry.\n \n ## The case this closes, which no existing guard catches\n \n `isLeaseMechanismWritable` is evaluated on the SWEEP's pod. A per-pod failure — the executing\n * pod's Redis connection is broken while the sweep's is fine — passes it, `isTurnAlive`\n * truthfully reports no lease, and a healthy running turn is durably recorded FAILED. That\n * inversion has no compensating pass; it is the reason this method exists.\n \n ## How the two are told apart\n \n 1. An establishment marker ({@link LEASE_ESTABLISHED_KEY_PREFIX}) is written beside every\n * successful lease write and outlives it by hours. Present ⇒ a pod demonstrably held this\n * task and stopped ⇒ `LEASE_LAPSED`, a verdict, on the very first pass. This is what keeps\n * ordinary abandonment repaired in the same hour it happens.\n * 2. Otherwise the reading is indeterminate, and the answer is TIME rather than another key:\n * a live pod that merely failed one write rewrites its lease on the next 10-second heartbeat,\n * so an absence that is still there a full sweep period later is not a missed write. The\n * first pass records the observation and returns `FIRST_ABSENCE`; a later pass that still\n * finds no lease and still finds the observation returns `CORROBORATED_ABSENCE`.\n * 3. If the observation can neither be read nor written, nothing was learned —\n * `UNDETERMINED`. It is NOT collapsed into `FIRST_ABSENCE`, because that one made progress\n * toward a verdict and this one did not; recording it as progress would let two enquiries\n * that both failed add up to a durable kill.\n \n Losing the medium fails toward the SAFE side in both directions: with the markers gone (a\n * Redis restart) every absence is merely uncorroborated, so genuine abandonment is still\n * repaired — one run later — while a healthy turn is not killed on a single reading.\n /\n public async corroborateAbandonment(taskId: string): Promise<A2A_AbandonmentEvidence> {\n // No client at all is the one case where this method can say nothing whatsoever. The sweep's\n // fleet-wide abstain already refuses to run in that state, so reaching here means the client\n // died between that probe and this row — indeterminate, by construction.\n if (!this.redisService.getReadyClient()) return A2A_AbandonmentEvidence.UNDETERMINED;\n\n try {\n if (await this.redisService.exists(this.leaseEstablishedKey(taskId))) return A2A_AbandonmentEvidence.LEASE_LAPSED;\n\n const observationKey = this.absenceObservationKey(taskId);\n if (await this.redisService.exists(observationKey)) return A2A_AbandonmentEvidence.CORROBORATED_ABSENCE;\n\n // Record THIS observation so a later run can corroborate it. The write is inside the same\n // try as the reads on purpose: an observation that was not durably recorded has not been\n // made, and reporting `FIRST_ABSENCE` for it would let the next run corroborate against\n // nothing.\n await this.redisService.set(observationKey, '1', { ttl: A2A_TASK_ABSENCE_OBSERVATION_TTL_SECONDS });\n return A2A_AbandonmentEvidence.FIRST_ABSENCE;\n } catch (error) {\n this.logger.warn('[A2ATaskCancel] Could not establish why a task lease is absent; the sweep will not act on this reading', {\n taskId,\n ...projectCaughtErrorLogFields(error),\n });\n return A2A_AbandonmentEvidence.UNDETERMINED;\n }\n }\n\n /\n Can the lease mechanism actually be WRITTEN right now?\n \n Read by the abandoned-task sweep before it repairs anything, and only by it (review\n * finding A3-4). The distinction that makes this necessary: `isTurnAlive` fails safe by\n * answering \"alive\", so a degraded Redis costs a stale `working` — recoverable, and the next\n * poll corrects it. The SWEEP is the one consumer that turns a liveness answer into a\n * DURABLE terminal status, so it is the one that must refuse to act on a signal it cannot\n * trust.\n \n A WRITE probe specifically, not a read: the dangerous failure mode is asymmetric — writes\n * failing while reads succeed (a read-only replica, an OOM/quota condition). Under that\n * failure every live turn's lease is missing while `exists` cheerfully reports it absent, so\n * a read-based health check would pass and the sweep would fail every healthy task in the\n * fleet. Probing the exact capability whose loss causes the false reading is the only check\n * that catches it.\n */\n public async isLeaseMechanismWritable(): Promise<boolean> {\n if (!this.redisService.getReadyClient()) return false;\n const probeKey = this.leaseKey('__sweep-health-probe__');\n try {\n await this.redisService.set(probeKey, '1', { ttl: A2A_TASK_LEASE_TTL_SECONDS });\n const present = await this.redisService.exists(probeKey);\n await this.redisService.del(probeKey).catch(() => {});\n return present;\n } catch {\n return false;\n }\n }\n}\n"]}
1	+ {"version":3,"file":"a2a-task-cancellation.backend.service.js","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/services/a2a-task-cancellation.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;;;;;;;;;;;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAGpF,OAAO,EAAE,2BAA2B,EAAE,MAAM,8EAA8E,CAAC;AAC3H,OAAO,EAAE,uBAAuB,EAAE,MAAM,gEAAgE,CAAC;AAEzG,6FAA6F;AAC7F,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;AAChD,qFAAqF;AACrF,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAC3C;;;;;;;GAOG;AACH,MAAM,4BAA4B,GAAG,uBAAuB,CAAC;AAC7D;;;;GAIG;AACH,MAAM,kCAAkC,GAAG,wBAAwB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wCAAwC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;AAG7D,IAAM,iCAAiC,GAAvC,MAAM,iCAAiC;IAUU;IACM;IAV5D,+EAA+E;IAC9D,UAAU,GAAG,IAAI,GAAG,EAA2B,CAAC;IACjE,6DAA6D;IAC5C,WAAW,GAAG,IAAI,GAAG,EAA0B,CAAC;IAEzD,UAAU,GAA2B,IAAI,CAAC;IAC1C,gBAAgB,GAAG,KAAK,CAAC;IAEjC,YACsD,MAAqB,EACf,YAA0B;QADhC,WAAM,GAAN,MAAM,CAAe;QACf,iBAAY,GAAZ,YAAY,CAAc;IACnF,CAAC;IAEI,OAAO;QACb,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,GAAG,qBAAqB,EAAE,CAAC;IACvE,CAAC;IAEO,QAAQ,CAAC,MAAc;QAC7B,OAAO,GAAG,gBAAgB,GAAG,MAAM,EAAE,CAAC;IACxC,CAAC;IAEO,mBAAmB,CAAC,MAAc;QACxC,OAAO,GAAG,4BAA4B,GAAG,MAAM,EAAE,CAAC;IACpD,CAAC;IAEO,qBAAqB,CAAC,MAAc;QAC1C,OAAO,GAAG,kCAAkC,GAAG,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED;;;;;;;;;;OAUG;IACK,KAAK,CAAC,gBAAgB;QAC5B,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO;QAClC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAE7B,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;QAClD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qFAAqF,CAAC,CAAC;YACzG,OAAO;QACT,CAAC;QAED,IAAI,UAAuC,CAAC;QAC5C,IAAI,CAAC;YACH,UAAU,GAAG,MAAM,CAAC,SAAS,EAAqB,CAAC;YACnD,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE;gBACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iDAAiD,EAAE,EAAE,GAAG,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAClH,CAAC,CAAC,CAAC;YACH,4FAA4F;YAC5F,8FAA8F;YAC9F,6FAA6F;YAC7F,6FAA6F;YAC7F,2FAA2F;YAC3F,6EAA6E;YAC7E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0FAA0F,CAAC,CAAC;gBAC7G,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;gBAC5B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAChC,CAAC,CAAC,CAAC;YACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;YAC3B,MAAM,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,OAAe,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;YACjG,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iFAAiF;YACjF,yEAAyE;YACzE,sFAAsF;YACtF,oFAAoF;YACpF,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC;oBAAC,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;gBAAC,CAAC;gBAAC,MAAM,CAAC,CAAC,uCAAuC,CAAC,CAAC;YACvF,CAAC;YACD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC,8BAA8B;YAC7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2DAA2D,EAAE,EAAE,GAAG,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC5H,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,iBAAiB,CAAC,MAAc;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gEAAgE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/F,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,SAAS,CAAC,MAAc;QACnC,oFAAoF;QACpF,wFAAwF;QACxF,qFAAqF;QACrF,yFAAyF;QACzF,0EAA0E;QAC1E,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAExC,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IAAI,yBAAyB,GAAG,KAAK,CAAC;QACtC,MAAM,OAAO,GAAG,KAAK,IAAmB,EAAE;YACxC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,CAAC,CAAC;gBAC7F,yFAAyF;gBACzF,sFAAsF;gBACtF,qFAAqF;gBACrF,0FAA0F;gBAC1F,gFAAgF;gBAChF,qCAAqC;gBACrC,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,sCAAsC,EAAE,CAAC,CAAC;gBACpH,gBAAgB,GAAG,IAAI,CAAC;YAC1B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,mFAAmF;gBACnF,+CAA+C;gBAC/C,EAAE;gBACF,oFAAoF;gBACpF,mFAAmF;gBACnF,mFAAmF;gBACnF,qFAAqF;gBACrF,kFAAkF;gBAClF,+EAA+E;gBAC/E,IAAI,gBAAgB,EAAE,CAAC;oBACrB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE,EAAE,MAAM,EAAE,GAAG,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;oBAC5G,OAAO;gBACT,CAAC;gBACD,0FAA0F;gBAC1F,yFAAyF;gBACzF,0FAA0F;gBAC1F,yBAAyB;gBACzB,IAAI,yBAAyB;oBAAE,OAAO;gBACtC,yBAAyB,GAAG,IAAI,CAAC;gBACjC,uFAAuF;gBACvF,sFAAsF;gBACtF,yFAAyF;gBACzF,0FAA0F;gBAC1F,0FAA0F;gBAC1F,8CAA8C;gBAC9C,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC;oBACxC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oHAAoH,EAAE;wBACrI,MAAM;wBACN,WAAW,EAAE,mGAAmG;wBAChH,GAAG,2BAA2B,CAAC,KAAK,CAAC;qBACtC,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qGAAqG,EAAE;oBACvH,MAAM;oBACN,WAAW,EAAE,kIAAkI;oBAC/I,GAAG,2BAA2B,CAAC,KAAK,CAAC;iBACtC,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC;QACF,MAAM,OAAO,EAAE,CAAC;QAChB,+EAA+E;QAC/E,kFAAkF;QAClF,qFAAqF;QACrF,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,QAAQ;YAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;QAEtC,6FAA6F;QAC7F,EAAE;QACF,2FAA2F;QAC3F,yFAAyF;QACzF,8FAA8F;QAC9F,yFAAyF;QACzF,uFAAuF;QACvF,4EAA4E;QAC5E,EAAE;QACF,8FAA8F;QAC9F,6FAA6F;QAC7F,oFAAoF;QACpF,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,yBAAyB,CAAC,CAAC;QAChF,kFAAkF;QAClF,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAChB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAEpC,qFAAqF;QACrF,mFAAmF;QACnF,wFAAwF;QACxF,kCAAkC;QAClC,KAAK,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE7B,OAAO,UAAU,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,OAAO,CAAC,MAAc;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,KAAK,EAAE,CAAC;YACV,aAAa,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,0DAA0D;YAC1D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,6CAA6C,EAAE,EAAE,MAAM,EAAE,GAAG,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrH,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,aAAa,CAAC,MAAc;QACvC,mFAAmF;QACnF,sEAAsE;QACtE,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,KAAK;YAAE,KAAK,CAAC,KAAK,EAAE,CAAC;QAEzB,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;QAClD,IAAI,CAAC,MAAM;YAAE,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QAEnC,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8CAA8C,EAAE,EAAE,MAAM,EAAE,GAAG,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACrH,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACI,KAAK,CAAC,WAAW,CAAC,MAAc;QACrC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC;QAC7C,wFAAwF;QACxF,0FAA0F;QAC1F,0FAA0F;QAC1F,oEAAoE;QACpE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE;YAAE,OAAO,IAAI,CAAC;QACrD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/D,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACI,KAAK,CAAC,sBAAsB,CAAC,MAAc;QAChD,6FAA6F;QAC7F,6FAA6F;QAC7F,yEAAyE;QACzE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE;YAAE,OAAO,uBAAuB,CAAC,YAAY,CAAC;QAErF,IAAI,CAAC;YACH,IAAI,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBAAE,OAAO,uBAAuB,CAAC,YAAY,CAAC;YAElH,MAAM,cAAc,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;YAC1D,IAAI,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC;gBAAE,OAAO,uBAAuB,CAAC,oBAAoB,CAAC;YAExG,0FAA0F;YAC1F,yFAAyF;YACzF,wFAAwF;YACxF,WAAW;YACX,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,cAAc,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,wCAAwC,EAAE,CAAC,CAAC;YACpG,OAAO,uBAAuB,CAAC,aAAa,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wGAAwG,EAAE;gBACzH,MAAM;gBACN,GAAG,2BAA2B,CAAC,KAAK,CAAC;aACtC,CAAC,CAAC;YACH,OAAO,uBAAuB,CAAC,YAAY,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,KAAK,CAAC,wBAAwB;QACnC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE;YAAE,OAAO,KAAK,CAAC;QACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;QACzD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,CAAC,CAAC;YAChF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACzD,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YACtD,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;CACF,CAAA;AAhXY,iCAAiC;IAD7C,UAAU,EAAE;IAWR,WAAA,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAA;IACjC,WAAA,MAAM,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;;GAX/B,iCAAiC,CAgX7C","sourcesContent":["/*\n Cross-pod A2A task cancellation.\n \n ## You do not need to find the executing pod\n \n With several backend replicas behind a load balancer, a `tasks/cancel` request\n * almost never lands on the pod that is running that task's LLM turn. The obvious\n * design — discover which pod owns it and route there — needs a pod registry, a\n * liveness view of it, and an internal call path, and it is wrong on every one of\n * those axes when a pod restarts mid-turn.\n \n Instead this BROADCASTS. Any pod publishes `{taskId}` to one Redis channel; every\n * pod runs a single shared subscriber; only the pod holding that `taskId` in its\n * in-process registry reacts. One connection per pod, no routing table, and a pod\n * that died simply does not answer — which is the correct behaviour, not an error to\n * handle.\n \n Rejected alternative: polling a Redis flag inside the token loop. That puts a GET on\n * the hottest path in the system (per N tokens, per concurrent turn) and bounds\n * cancellation latency by token cadence. Pub/sub costs nothing per token.\n \n ## Liveness is the same mechanism's other half\n \n While a pod owns a turn it refreshes a TTL'd lease key. That is what lets\n * `tasks/get` report an abandoned task honestly instead of leaving it `working`\n * forever after a pod dies — see the lease helpers below.\n \n An absent lease is NOT self-explanatory, though, and reading it as death is an inversion that\n * costs real work: a pod that could not write the lease looks exactly like a pod that died. So\n * every successful lease write also leaves a long-lived ESTABLISHMENT marker, and\n * `corroborateAbandonment` is what turns \"no lease\" into either a verdict or an admission that\n * nothing was learned. Only the sweep — the one consumer that makes a liveness answer DURABLE —\n * asks that question.\n /\n\nimport { inject, injectable } from 'inversify';\nimport type { RedisClientType } from 'redis';\n\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport type { LoggerService } from '~wildo-backend-lib/monitoring/logger/services/logger.service';\nimport type { RedisService } from '~wildo-backend-lib/databases/services/redis.service';\nimport { projectCaughtErrorLogFields } from '~wildo-backend-lib/errors/utils/error-log-level-classification.backend.utils';\nimport { A2A_AbandonmentEvidence } from '~wildo-backend-lib/flows-actors/a2a/models/a2a.backend.schemas';\n\n/* Channel every replica subscribes to. App-prefixed so tenants of one Redis never cross. /\nconst CANCEL_CHANNEL_SUFFIX = 'a2a:task:cancel';\n/* Lease key prefix — presence means \"a live pod is working this task right now\". /\nconst LEASE_KEY_PREFIX = 'a2a:task:lease:';\n/\n ESTABLISHMENT marker prefix — presence means \"this task's liveness WAS observable at some point\n * recently\", which is a different fact from \"it is alive now\" and has a different lifetime.\n \n It is what makes an absent lease MEAN something (see {@link A2A_AbandonmentEvidence}). Written\n * by the same code path and in the same failure domain as the lease itself, so it can only exist\n * if a write actually succeeded — which is exactly the property being recorded.\n /\nconst LEASE_ESTABLISHED_KEY_PREFIX = 'a2a:task:leased-once:';\n/\n The sweep's own note that it has already seen one unexplained absence for a task. Written by the\n * SWEEP's pod, whose write capability `isLeaseMechanismWritable` proved moments earlier — so the\n * medium is known-good at the point of use, unlike the lease itself.\n /\nconst ABANDONMENT_OBSERVATION_KEY_PREFIX = 'a2a:task:absence-seen:';\n\n/\n Lease TTL and refresh cadence. The refresh interval is deliberately well under the\n * TTL: a single missed refresh (GC pause, a slow Redis round-trip) must not make a\n * healthy turn look abandoned. Only a genuinely dead pod stops refreshing.\n /\nexport const A2A_TASK_LEASE_TTL_SECONDS = 30;\nexport const A2A_TASK_LEASE_REFRESH_MS = 10_000;\n\n/\n How long the establishment marker outlives its last refresh.\n \n Sized to comfortably span the sweep's grace window plus its hourly period, so a pod that dies\n * mid-turn is still recognisable as HAVING held the task when the next sweep looks. It is a\n * timing optimisation, never a correctness requirement: if it lapses, the reading degrades to\n * {@link A2A_AbandonmentEvidence.FIRST_ABSENCE} and the row is repaired one run later instead of\n * on the first — which is the direction this whole mechanism errs in anyway.\n /\nexport const A2A_TASK_LEASE_ESTABLISHED_TTL_SECONDS = 6 60 * 60;\n\n/*\n How long one unexplained absence stands as corroboration for the next run.\n \n MUST exceed the sweep's period or no observation ever survives to be corroborated and nothing\n * is ever repaired through that path; generous beyond it so a skipped run (the fleet-wide abstain)\n * does not reset the count. Nothing clears it on recovery, and it does not need clearing: a task\n * whose pod recovered answers ALIVE on the lease long before this is consulted, and once its lease\n * lapses for real the establishment marker gives the verdict directly.\n /\nexport const A2A_TASK_ABSENCE_OBSERVATION_TTL_SECONDS = 3 60 * 60;\n\n@injectable()\nexport class A2ATaskCancellationBackendService {\n /** Tasks this pod is currently executing → the controller that aborts them. /\n private readonly localTurns = new Map<string, AbortController>();\n /* Lease heartbeats keyed by task id, cleared on release. /\n private readonly leaseTimers = new Map<string, NodeJS.Timeout>();\n\n private subscriber: RedisClientType \| null = null;\n private subscribeStarted = false;\n\n constructor(\n @inject(SAAS_SERVICE_TYPES.Logger) private readonly logger: LoggerService,\n @inject(SAAS_SERVICE_TYPES.RedisService) private readonly redisService: RedisService,\n ) {}\n\n private channel(): string {\n return `${this.redisService.getAppPrefix()}${CANCEL_CHANNEL_SUFFIX}`;\n }\n\n private leaseKey(taskId: string): string {\n return `${LEASE_KEY_PREFIX}${taskId}`;\n }\n\n private leaseEstablishedKey(taskId: string): string {\n return `${LEASE_ESTABLISHED_KEY_PREFIX}${taskId}`;\n }\n\n private absenceObservationKey(taskId: string): string {\n return `${ABANDONMENT_OBSERVATION_KEY_PREFIX}${taskId}`;\n }\n\n /\n Start this pod's single shared subscriber. Idempotent — safe to call from every\n * turn, so no startup ordering is required.\n \n `node-redis` forbids commands on a subscribed connection, so the subscriber MUST be\n * a duplicate rather than the shared client. Same pattern the WebSocket adapter uses.\n \n Fails OPEN by design: if Redis is unreachable the turn still runs — losing the\n * ability to cancel is strictly better than refusing to answer at all. The failure is\n * logged at ERROR because a persistent one silently disables cancellation fleet-wide.\n /\n private async ensureSubscriber(): Promise<void> {\n if (this.subscribeStarted) return;\n this.subscribeStarted = true;\n\n const client = this.redisService.getReadyClient();\n if (!client) {\n this.logger.error('[A2ATaskCancel] Redis unavailable — cross-pod cancellation is DISABLED for this pod');\n return;\n }\n\n let subscriber: RedisClientType \| undefined;\n try {\n subscriber = client.duplicate() as RedisClientType;\n subscriber.on('error', (error: unknown) => {\n this.logger.error('[A2ATaskCancel] Cancel-channel subscriber error', { ...projectCaughtErrorLogFields(error) });\n });\n // REARM on a later death (review finding L-2). `subscribeStarted` was reset only inside the\n // SETUP catch, so a subscriber that connected and then dropped — a Redis restart, a failover,\n // an idle-timeout reap — logged from the handler above and was never rebuilt for the rest of\n // the pod's lifetime. Cross-pod cancellation then silently stopped working on that pod while\n // every other signal still looked healthy: the turns run, the leases refresh, and only the\n // broadcast never arrives. Clearing the latch lets the next turn rebuild it.\n subscriber.on('end', () => {\n this.logger.warn('[A2ATaskCancel] Cancel-channel subscriber closed; re-arming so the next turn rebuilds it');\n this.subscriber = undefined;\n this.subscribeStarted = false;\n });\n await subscriber.connect();\n await subscriber.subscribe(this.channel(), (message: string) => this.onCancelBroadcast(message));\n this.subscriber = subscriber;\n } catch (error) {\n // DESTROY the half-built connection before retrying. `connect()` can succeed and\n // `subscribe()` still throw, which leaves a live, unusable socket; since\n // `subscribeStarted` resets to allow a retry, every later turn would open another one\n // and leak a Redis connection per turn until the pod hit its file-descriptor limit.\n if (subscriber) {\n try { await subscriber.destroy(); } catch { / already dead — nothing to reclaim / }\n }\n this.subscribeStarted = false; // allow a later turn to retry\n this.logger.error('[A2ATaskCancel] Failed to subscribe to the cancel channel', { ...projectCaughtErrorLogFields(error) });\n }\n }\n\n /\n Handle a broadcast. Every pod receives every cancel; only the owner acts, and a pod\n * that does not own the task does nothing at all — that silence is the design, not a\n * missed message.\n /\n private onCancelBroadcast(taskId: string): void {\n const controller = this.localTurns.get(taskId);\n if (!controller) return;\n this.logger.info('[A2ATaskCancel] Aborting a locally-executing turn on broadcast', { taskId });\n controller.abort();\n }\n\n /\n Register a turn as executing on this pod: returns the signal to hand to the model\n * call, and starts the liveness lease.\n /\n public async beginTurn(taskId: string): Promise<AbortSignal> {\n // ORDER IS LOAD-BEARING. Register locally and write the lease BEFORE the subscriber\n // setup, which on the first turn performs a full Redis duplicate + connect + subscribe.\n // Awaiting that first would leave a window in which the task is materialised and the\n // client — which asked for a non-blocking turn precisely so it could poll at once — sees\n // a non-terminal task with no lease and is told FAILED by derive-on-read.\n const controller = new AbortController();\n this.localTurns.set(taskId, controller);\n\n let leaseEverWritten = false;\n let unwritableAlreadyReported = false;\n const refresh = async (): Promise<void> => {\n try {\n await this.redisService.set(this.leaseKey(taskId), '1', { ttl: A2A_TASK_LEASE_TTL_SECONDS });\n // The ESTABLISHMENT marker rides the same write, in the same failure domain, and is what\n // makes a LATER absence of the lease mean something: a reader that finds no lease but\n // finds this knows a pod really did hold the task and stopped, rather than that this\n // task's liveness was never observable at all. Written every refresh so a long turn keeps\n // it alive; deliberately NOT written before the lease, so it can never claim an\n // establishment that did not happen.\n await this.redisService.set(this.leaseEstablishedKey(taskId), '1', { ttl: A2A_TASK_LEASE_ESTABLISHED_TTL_SECONDS });\n leaseEverWritten = true;\n } catch (error) {\n // A missed REFRESH is survivable — the TTL is several refreshes long, so the lease\n // written earlier still answers for this turn.\n //\n // A lease that was NEVER successfully written is a different thing entirely (review\n // finding A3-4), and it used to log identically. No other pod can distinguish \"the\n // write failed\" from \"the pod died\": `tasks/get` on any other replica reports this\n // healthy running turn as FAILED, and the sweep then makes that answer DURABLE. This\n // is the write-side twin of the read-side hole G2-8 closed — the JSDoc claim that\n // \"only a genuinely dead pod stops refreshing\" was false in exactly this case.\n if (leaseEverWritten) {\n this.logger.warn('[A2ATaskCancel] Lease refresh failed', { taskId, ...projectCaughtErrorLogFields(error) });\n return;\n }\n // ONCE per turn, not once per heartbeat. The heartbeat now runs even with no Redis at all\n // (see below), so an unconditional log here would emit a line every 10 seconds for every\n // concurrent turn of a Redis-less deployment — which is how a channel that carries a real\n // signal gets tuned out.\n if (unwritableAlreadyReported) return;\n unwritableAlreadyReported = true;\n // The two causes are logged at DIFFERENT levels because one is a configuration and the\n // other is a fault. No client on this pod is the supported single-replica / local-dev\n // shape: `isTurnAlive` fails safe toward \"alive\" there and nothing reads liveness across\n // pods, so it is a WARN. A client that is present and REJECTED the write is the dangerous\n // asymmetry — this pod is partitioned from a liveness plane every other replica can still\n // read — and it keeps the ERROR level it had.\n if (!this.redisService.getReadyClient()) {\n this.logger.warn('[A2ATaskCancel] No Redis on this pod; this turn has no liveness lease and cannot be cancelled from another replica', {\n taskId,\n consequence: 'harmless on a single replica; on a fleet, other pods cannot observe this turn until Redis returns',\n ...projectCaughtErrorLogFields(error),\n });\n return;\n }\n this.logger.error('[A2ATaskCancel] Task lease has NEVER been written; other pods will read this live turn as abandoned', {\n taskId,\n consequence: 'tasks/get on another replica reports failed until a later refresh lands; the sweep now abstains rather than recording it durably',\n ...projectCaughtErrorLogFields(error),\n });\n }\n };\n await refresh();\n // Clear any prior heartbeat for this id before replacing it. Unreachable today\n // (task ids are freshly minted uuids), but an overwritten `setInterval` handle is\n // unclearable — it would refresh a lease forever and keep a dead task looking alive.\n const existing = this.leaseTimers.get(taskId);\n if (existing) clearInterval(existing);\n\n // ── The heartbeat is installed UNCONDITIONALLY, and that is a fix, not a tidy-up ──────────\n //\n // This whole block used to sit behind `if (this.redisService.getReadyClient())`, so a turn\n // that began while this pod's client was not ready got NO lease and NO retry — it stayed\n // unobservable for its entire life even after Redis came back, and nothing was logged at all,\n // because the failing write never even ran. That is the SILENT half of the inversion the\n // never-written branch above documents, and it is strictly worse: a failed first write\n // self-heals on the next 10-second refresh, an absent heartbeat never does.\n //\n // The cost in a genuinely Redis-less deployment is one unref'd timer per in-flight turn and a\n // caught rejection every 10 seconds; the log is emitted once (above), and `redisService.set`\n // builds its error without logging. That is cheap enough to buy automatic recovery.\n const timer = setInterval(() => { void refresh(); }, A2A_TASK_LEASE_REFRESH_MS);\n // Never hold the event loop open on a heartbeat — a draining pod must still exit.\n timer.unref?.();\n this.leaseTimers.set(taskId, timer);\n\n // Subscriber setup happens AFTER the lease exists (see the note above). Not awaited:\n // a slow Redis handshake must not delay the turn, and a cancel arriving before the\n // subscription is live is already handled — `requestCancel` aborts a locally-owned turn\n // directly, without a round-trip.\n void this.ensureSubscriber();\n\n return controller.signal;\n }\n\n /\n Release a finished turn: stop the heartbeat, drop the lease, forget the controller.\n \n Dropping the lease EAGERLY matters — a terminal task with a live lease would look\n * like it is still executing to anything reading liveness.\n \n The ESTABLISHMENT marker is deliberately NOT dropped with it. The two record different kinds\n * of fact: the lease says \"a pod is working this NOW\" and stops being true the instant the turn\n * unwinds, while the marker says \"this task's liveness was observable\", which stays true\n * afterwards. Keeping it also covers the one case that would otherwise regress — a turn that\n * finished but whose terminal write did not land — since the row is then genuinely abandoned and\n * the sweep can say so on its first pass instead of waiting for corroboration. It expires on its\n * own TTL, so nothing accumulates.\n /\n public async endTurn(taskId: string): Promise<void> {\n const timer = this.leaseTimers.get(taskId);\n if (timer) {\n clearInterval(timer);\n this.leaseTimers.delete(taskId);\n }\n this.localTurns.delete(taskId);\n try {\n await this.redisService.del(this.leaseKey(taskId));\n } catch (error) {\n // The TTL reaps it anyway; this only shortens the window.\n this.logger.warn('[A2ATaskCancel] Failed to drop a task lease', { taskId, ...projectCaughtErrorLogFields(error) });\n }\n }\n\n /\n Ask the fleet to cancel a task.\n \n Returns whether the request was BROADCAST, never whether it was honoured: the owning\n * pod may be gone, or the turn may already have finished. The caller must therefore\n * treat the task record — not this return value — as the truth about cancellation,\n * which is also what the A2A spec requires (`tasks/cancel` returns the task's updated\n * state, not an acknowledgement).\n /\n public async requestCancel(taskId: string): Promise<boolean> {\n // A turn owned by THIS pod is aborted directly — no round-trip, and it still works\n // when Redis is down, which is the single-replica and local-dev case.\n const local = this.localTurns.get(taskId);\n if (local) local.abort();\n\n const client = this.redisService.getReadyClient();\n if (!client) return Boolean(local);\n\n try {\n await client.publish(this.channel(), taskId);\n return true;\n } catch (error) {\n this.logger.error('[A2ATaskCancel] Failed to broadcast a cancel', { taskId, ...projectCaughtErrorLogFields(error) });\n return Boolean(local);\n }\n }\n\n /\n Is some pod still working this task?\n \n This is the read half of the liveness design: a task whose stored status is\n * non-terminal but whose lease has expired was abandoned by a pod that died, and must\n * be reported as failed rather than left reading `working` forever.\n \n Fails SAFE toward \"alive\" when Redis is unreachable — reporting a healthy task as\n * abandoned because the cache blipped would be a far worse lie than a brief stale\n * `working`.\n /\n public async isTurnAlive(taskId: string): Promise<boolean> {\n if (this.localTurns.has(taskId)) return true;\n // Redis ABSENT is not evidence of death. `RedisService.exists` RETURNS FALSE when there\n // is no client rather than throwing, so the catch below never fired for that case and the\n // documented \"fails safe toward alive\" was untrue: with Redis down, every task on another\n // pod would have been reported FAILED. Check the client explicitly.\n if (!this.redisService.getReadyClient()) return true;\n try {\n return await this.redisService.exists(this.leaseKey(taskId));\n } catch {\n return true;\n }\n }\n\n /\n WHY is this task's lease absent — and may that absence be turned into a durable verdict?\n \n Asked by the abandoned-task sweep, and only by it, AFTER {@link isTurnAlive} has already\n * answered \"no lease\". `isTurnAlive` returns a boolean because every other consumer only needs\n * to know whether to keep waiting; the sweep is the one caller that writes a TERMINAL status,\n * so it is the one caller that must be able to tell a verdict from a failed enquiry.\n \n ## The case this closes, which no existing guard catches\n \n `isLeaseMechanismWritable` is evaluated on the SWEEP's pod. A per-pod failure — the executing\n * pod's Redis connection is broken while the sweep's is fine — passes it, `isTurnAlive`\n * truthfully reports no lease, and a healthy running turn is durably recorded FAILED. That\n * inversion has no compensating pass; it is the reason this method exists.\n \n ## How the two are told apart\n \n 1. An establishment marker ({@link LEASE_ESTABLISHED_KEY_PREFIX}) is written beside every\n * successful lease write and outlives it by hours. Present ⇒ a pod demonstrably held this\n * task and stopped ⇒ `LEASE_LAPSED`, a verdict, on the very first pass. This is what keeps\n * ordinary abandonment repaired in the same hour it happens.\n * 2. Otherwise the reading is indeterminate, and the answer is TIME rather than another key:\n * a live pod that merely failed one write rewrites its lease on the next 10-second heartbeat,\n * so an absence that is still there a full sweep period later is not a missed write. The\n * first pass records the observation and returns `FIRST_ABSENCE`; a later pass that still\n * finds no lease and still finds the observation returns `CORROBORATED_ABSENCE`.\n * 3. If the observation can neither be read nor written, nothing was learned —\n * `UNDETERMINED`. It is NOT collapsed into `FIRST_ABSENCE`, because that one made progress\n * toward a verdict and this one did not; recording it as progress would let two enquiries\n * that both failed add up to a durable kill.\n \n Losing the medium fails toward the SAFE side in both directions: with the markers gone (a\n * Redis restart) every absence is merely uncorroborated, so genuine abandonment is still\n * repaired — one run later — while a healthy turn is not killed on a single reading.\n /\n public async corroborateAbandonment(taskId: string): Promise<A2A_AbandonmentEvidence> {\n // No client at all is the one case where this method can say nothing whatsoever. The sweep's\n // fleet-wide abstain already refuses to run in that state, so reaching here means the client\n // died between that probe and this row — indeterminate, by construction.\n if (!this.redisService.getReadyClient()) return A2A_AbandonmentEvidence.UNDETERMINED;\n\n try {\n if (await this.redisService.exists(this.leaseEstablishedKey(taskId))) return A2A_AbandonmentEvidence.LEASE_LAPSED;\n\n const observationKey = this.absenceObservationKey(taskId);\n if (await this.redisService.exists(observationKey)) return A2A_AbandonmentEvidence.CORROBORATED_ABSENCE;\n\n // Record THIS observation so a later run can corroborate it. The write is inside the same\n // try as the reads on purpose: an observation that was not durably recorded has not been\n // made, and reporting `FIRST_ABSENCE` for it would let the next run corroborate against\n // nothing.\n await this.redisService.set(observationKey, '1', { ttl: A2A_TASK_ABSENCE_OBSERVATION_TTL_SECONDS });\n return A2A_AbandonmentEvidence.FIRST_ABSENCE;\n } catch (error) {\n this.logger.warn('[A2ATaskCancel] Could not establish why a task lease is absent; the sweep will not act on this reading', {\n taskId,\n ...projectCaughtErrorLogFields(error),\n });\n return A2A_AbandonmentEvidence.UNDETERMINED;\n }\n }\n\n /\n Can the lease mechanism actually be WRITTEN right now?\n \n Read by the abandoned-task sweep before it repairs anything, and only by it (review\n * finding A3-4). The distinction that makes this necessary: `isTurnAlive` fails safe by\n * answering \"alive\", so a degraded Redis costs a stale `working` — recoverable, and the next\n * poll corrects it. The SWEEP is the one consumer that turns a liveness answer into a\n * DURABLE terminal status, so it is the one that must refuse to act on a signal it cannot\n * trust.\n \n A WRITE probe specifically, not a read: the dangerous failure mode is asymmetric — writes\n * failing while reads succeed (a read-only replica, an OOM/quota condition). Under that\n * failure every live turn's lease is missing while `exists` cheerfully reports it absent, so\n * a read-based health check would pass and the sweep would fail every healthy task in the\n * fleet. Probing the exact capability whose loss causes the false reading is the only check\n * that catches it.\n */\n public async isLeaseMechanismWritable(): Promise<boolean> {\n if (!this.redisService.getReadyClient()) return false;\n const probeKey = this.leaseKey('__sweep-health-probe__');\n try {\n await this.redisService.set(probeKey, '1', { ttl: A2A_TASK_LEASE_TTL_SECONDS });\n const present = await this.redisService.exists(probeKey);\n await this.redisService.del(probeKey).catch(() => {});\n return present;\n } catch {\n return false;\n }\n }\n}\n"]}

package/dist/esm/flows-actors/a2a/services/a2a-task.backend.service.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"a2a-task.backend.service.d.ts","sourceRoot":"","sources":["~~../../../../../../~~src/flows-actors/a2a/services/a2a-task.backend.service.ts"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"a2a-task.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/a2a/services/a2a-task.backend.service.ts"],"names":[],"mappings":"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"}