@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-push-delivery-log.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-push-delivery-log.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A2A push-notification delivery log — one row per (task state change × registered webhook).\n *\n * ## Why this is a SIBLING of the M2M webhook delivery log rather than a variant of it\n *\n * The two share a delivery PATTERN — write the row before enqueueing, one queue job per row, the\n * worker classifies the response and either retries or terminates — and that pattern is reused\n * deliberately, down to the transport primitive. What they do not share is a SCOPE SET:\n * `M2MWebhookDeliveryLog` is stamped out for `ORGANIZATIONS` and `APPLICATION`, while an A2A task\n * can be owned by a **USER** as well. A delegated-user A2A caller is the ordinary case, not an edge\n * one, so extending the M2M resource would have meant adding a user-scoped variant — a whole\n * user-facing resource surface — to a shipped feature on behalf of a different subsystem.\n *\n * Keeping them separate also keeps the two producers separable in every query: a resource-operation\n * notification and a task-lifecycle notification are different facts about different things, and an\n * operator filtering one should never have to exclude the other by hand.\n *\n * ## Why the row is written BEFORE the delivery is attempted\n *\n * Copied from the M2M dispatcher's reasoning, because it is the property that makes this table\n * worth having: if the worker created the row on its first attempt, an unreachable queue would\n * leave no trace at all. Writing it up front means an operator always sees an entry per\n * (task transition × webhook), including the deliveries that never got as far as being tried.\n *\n * spec-cite: A2A 1.0 §4.3.3 — *\"Agents MUST attempt delivery at least once for each configured\n * webhook\"* — and §13.2, which asks for retry with exponential backoff and permits giving up after\n * a configured number of consecutive failures. This row is where all three become observable.\n *\n * @see notifications/m2m/m2m-webhook-delivery-log.shared.schemas.ts — the pattern this mirrors\n * @see a2a-token-budget-state.shared.schemas.ts — the 3-scope A2A polymorphic precedent\n */\n\nimport { z } from 'zod';\nimport { PersonalDataCategory } from '../compliance/privacy/personal-data-category.shared.schemas';\nimport { addDataCategories, initZodDecorators } from '@wildo-ai/zod-decorators';\n\nimport {\n  CoreResourceType,\n  coreResourceShared_FieldIdentifier,\n} from '../resources/resources.shared.core.definitions';\nimport {\n  declarePolymorphicSchemas,\n  optOutPolymorphicAutoBusinessKey,\n  type PolymorphicVariantDefinition,\n} from '../resources/utils/resource-polymorphism.schemas';\n\ninitZodDecorators(z);\n\n/**\n * The delivery lifecycle:\n *   PENDING → IN_FLIGHT → DELIVERED   (acknowledged with 2xx)\n *   PENDING → IN_FLIGHT → PENDING     (transient failure — retry scheduled with backoff)\n *   PENDING → IN_FLIGHT → FAILED      (terminal — non-retryable status, or attempts exhausted)\n *\n * Deliberately its OWN enum rather than a reuse of `M2MWebhookDeliveryLogStatus`, even though the\n * members coincide. That enum is named for, and owned by, the M2M notifications feature; importing\n * it here would couple flows-actors to that subsystem's release cycle for no gain, and would make\n * either feature's future state change a cross-feature edit. If a third outbound-delivery consumer\n * ever appears, the answer is to extract ONE shared vocabulary — not to have the second consumer\n * borrow the first one's.\n */\nexport enum A2APushDeliveryStatus {\n  PENDING = 'pending',\n  IN_FLIGHT = 'in_flight',\n  DELIVERED = 'delivered',\n  FAILED = 'failed',\n}\n\nexport const A2APushDeliveryLogSchema = z.object({\n  /** Document id — auto-generated / auto-managed (excluded from create). */\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n\n  /**\n   * The stable identity of this delivery, generated once when the row is written and sent with\n   * every attempt so a receiver can deduplicate.\n   *\n   * spec-cite: A2A 1.0 §4.3.3 — *\"Clients SHOULD process notifications idempotently, as duplicate\n   * deliveries may occur\"*. A client can only honour that if duplicates are RECOGNISABLE, which\n   * means the id must be stable across retries — hence generated at row creation, never per attempt.\n   */\n  deliveryId: z.string().min(1).isDBIndexed().isSummaryField(),\n\n  /** The task whose transition triggered this notification. */\n  taskId: z.string().min(1).isDBIndexed().isSummaryField(),\n\n  /** Which registered configuration this row delivers to — a task may have several. */\n  pushNotificationConfigId: z.string().min(1).isSummaryField(),\n\n  /**\n   * The agent instance the task belongs to. Carried so an operator can attribute deliveries per\n   * agent, and so a per-instance purge never reaches another agent's rows — the same isolation\n   * axis the task read enforces.\n   */\n  resourceServerInstanceRef: z.string().min(1).isDBIndexed().isSummaryField(),\n\n  /**\n   * The machine credential that owns the task, when one does.\n   *\n   * Carried because the worker must RE-READ the live configuration to obtain the client's\n   * credential (see the worker for why the secret is not copied onto this row), and that read\n   * enforces all four isolation axes. Without this field the read falls back to the \"no credential\"\n   * sentinel and matches nothing for any task a machine client created — which is most A2A tasks,\n   * since client-credentials auth is the ordinary way an agent connects.\n   *\n   * Optional rather than sentinel-defaulted: a delegated-user task genuinely has no machine\n   * credential, and storing a sentinel here would make \"absent\" and \"explicitly none\" the same\n   * value on a row whose whole job is to be evidence.\n   */\n  machineCredentialId: z.string().min(1).optional(),\n\n  /** The destination, captured as it was AT DISPATCH — a later config edit must not rewrite history. */\n  httpUrl: z.url(),\n\n  payloadHash: z.string().min(1),\n  // USER_CONTENT — the delivered payload carries the task's own content, which originated with the\n  // person. The declaration says what the field is FOR; a payload can hold anything a task held.\n  //\n  // `addDataCategories` rather than the fluent form: `z.unknown()` is one of the types that carry NO\n  // prototype-installed decorators at all (a decorator-WIDE gap, not specific to this one), so\n  // `.dataCategories(...)` does not type-check on it. The helper is the documented escape hatch.\n  payload: addDataCategories(z.unknown(), PersonalDataCategory.USER_CONTENT),\n\n  status: z\n    .enum(A2APushDeliveryStatus)\n    .default(A2APushDeliveryStatus.PENDING)\n    .isDBIndexed()\n    .isSummaryField(),\n\n  attemptCount: z.number().int().nonnegative().default(0).isSummaryField(),\n\n  lastAttemptAt: z.date().optional(),\n  /** When the next retry becomes eligible. Indexed — this is the worker's drain query. */\n  nextAttemptAt: z.date().optional().isDBIndexed(),\n\n  responseStatus: z.number().int().optional(),\n  /** Truncated by the worker before persistence: a webhook may answer with an unbounded body. */\n  responseBodyTruncated: z.string().optional(),\n  failureReason: z.string().optional().isSummaryField(),\n\n  deliveredAt: z.date().optional(),\n  failedAt: z.date().optional(),\n\n  createdAt: z\n    .date()\n    .default(() => new Date())\n    .isDBIndexed()\n    .isSummaryField(),\n});\n\nexport type A2APushDeliveryLogBase = z.infer<typeof A2APushDeliveryLogSchema>;\n\n/**\n * The three owner scopes an A2A task — and therefore its deliveries — can belong to.\n *\n * Mirrors `flowActorTasksPolymorphicDeclaration`'s scope set exactly, and must keep mirroring it: a\n * task owner with no delivery-log variant is a task whose notifications cannot be recorded, which\n * is the audit hole this table exists to close.\n */\nexport const A2A_PUSH_DELIVERY_SCOPE_VARIANTS: PolymorphicVariantDefinition[] = [\n  { parentResourceType: CoreResourceType.USERS,         parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.USERS],         isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.ORGANIZATIONS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS], isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.APPLICATION,   parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.APPLICATION],   isPrimaryScope: true },\n];\n\n/**\n * Produces 3 variants:\n *   - users         → `userA2aPushDeliveryLog`        (`userId` injected)\n *   - organizations → `organizationA2aPushDeliveryLog` (`organizationId` injected)\n *   - applications  → `applicationA2aPushDeliveryLog`  (`applicationId` injected)\n *\n * Multi-row, so it opts OUT of the singleton auto-business-key: unlike the token-budget\n * accumulator, there are many delivery rows per owner and the owner FK is not their identity.\n */\nexport const a2aPushDeliveryLogPolymorphicDeclaration = declarePolymorphicSchemas({\n  baseResourceType: 'a2aPushDeliveryLog',\n  baseFieldIdentifier: 'a2aPushDeliveryLogId',\n  baseEnumKey: 'A2A_PUSH_DELIVERY_LOG',\n  baseSchema: A2APushDeliveryLogSchema,\n  variants: A2A_PUSH_DELIVERY_SCOPE_VARIANTS.map(optOutPolymorphicAutoBusinessKey),\n});\n"]}

package/dist/esm/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A2A Token Budget State — Resource Configuration (POLYMORPHIC SINGLETON)
+ * ======================================================================
+ *
+ * The per-tenant A2A LLM token-budget accumulator, stamped out as THREE owner-scope
+ * singleton variants from one polymorphic declaration (`userA2aTokenBudgetState` /
+ * `organizationA2aTokenBudgetState` / `applicationA2aTokenBudgetState`). Spread the
+ * produced factories into the registry factory map:
+ *   ...a2aTokenBudgetStatePolymorphicFactories
+ *
+ * Access model — SYSTEM-WRITTEN, OWNER-READABLE:
+ *   - This is internal enforcement state, not user-authored data: only the A2A runtime WRITES
+ *     it, via `*AsSystem` (governed by `systemAccessPolicy`). The tenant may READ its own row
+ *     (a usage view: "how much of my allowance have I used?"), but never authors it.
+ *   - CREATE (`INTERNAL_CALL` super-admin, no explicit request DTO — it auto-derives per variant so
+ *     the injected owner FK is required on the correct variant) opens the singleton on the first
+ *     budgeted turn, via `createAsSystem`. `INTERNAL_CALL` (not `REPOSITORY_ONLY`) is mandatory
+ *     here: `*AsSystem` dispatches through the service tier and resolves the op via
+ *     `getServiceOperationPathDefault`, which only matches INTERNAL_CALL / API_CALL variants.
+ *   - There is deliberately NO `UPDATE` operation. Advancing the counter is an ATOMIC increment
+ *     (`RepositoriesRegistryHandlerBackendService.atomicIncrementField`) executed at the repository
+ *     tier, precisely so concurrent turns cannot lose tokens to a read-modify-write race — a
+ *     service-tier UPDATE cannot express that. Declaring an `UPDATE` op (with a DTO and a
+ *     `systemAccessPolicy.update` grant) would therefore be dead configuration describing a write
+ *     path nothing takes, and would invite a future contributor to route the counter through it and
+ *     silently reintroduce the race.
+ *   - DELETE is `INTERNAL_CALL` super-admin: it exists to satisfy the composition `onParentDelete`
+ *     cascade teardown (which runs at the repository tier and selects the operation-default DELETE,
+ *     irrespective of variant type), NOT to offer an HTTP surface. Deliberately NOT `API_CALL`:
+ *     zeroing this row zeroes recorded consumption, which is a SPEND-CAP BYPASS, so it gets no URL
+ *     at all — strictly stronger than relying on a role floor. (The role floor is nevertheless
+ *     platform-only for defence in depth.)
+ *   - READ is the ONE `API_CALL`, and it is owner-level on its own merit: a tenant inspecting its
+ *     own consumption ("how much of my allowance have I used?"). It is read-only, so it cannot
+ *     affect the cap.
+ *
+ * CASCADE NOTE (recorded because it was initially mis-diagnosed): the cascade's requirement is a
+ * cardinality-appropriate DISCOVERY op + a DELETE teardown op — for a 1:1 child that is READ, for
+ * 1:many it is LIST. It does NOT require a URL-isable variant: `supportsOperation` checks only
+ * `isOperationDefault`, and a sole `INTERNAL_CALL` variant is the default within its own group.
+ * The guard violation seen while building this resource came from the relationship declaring
+ * `childCardinality: MANY` (the helper's default) on a SINGLETON — which demanded LIST, not READ.
+ * Fixing the cardinality fixed it; verified by reverting DELETE to `INTERNAL_CALL` with the guard
+ * still green.
+ *
+ * @see a2a-token-budget-state.shared.schemas.ts — the polymorphic declaration + base schema
+ * @see flows-actors-execution.shared.resources-config.schemas.ts — the 3-scope polymorphic config precedent
+ */
+import { CoreResourceOperation } from '../resources/resources.shared.core.definitions';
+/**
+ * Polymorphic factory map for the A2A token budget state. Spread into
+ * `coreShared_ResourcesConfigurations_FactoryMap`:
+ *   ...a2aTokenBudgetStatePolymorphicFactories
+ *
+ * Produces entries for:
+ *   - userA2aTokenBudgetState
+ *   - organizationA2aTokenBudgetState
+ *   - applicationA2aTokenBudgetState
+ */
+export declare const a2aTokenBudgetStatePolymorphicFactories: Record<string, import("..").ResourceConfiguration_InitializationFactory<undefined, CoreResourceOperation.READ | CoreResourceOperation.DELETE | CoreResourceOperation.CREATE, any>>;
+//# sourceMappingURL=a2a-token-budget-state.shared.resources-config.schemas.d.ts.map

package/dist/esm/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-token-budget-state.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAAE,qBAAqB,EAAoB,MAAM,gDAAgD,CAAC;AA2BzG;;;;;;;;;GASG;AACH,eAAO,MAAM,uCAAuC,oLAsEnD,CAAC"}

package/dist/esm/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.js

@@ -0,0 +1,143 @@
+/**
+ * A2A Token Budget State — Resource Configuration (POLYMORPHIC SINGLETON)
+ * ======================================================================
+ *
+ * The per-tenant A2A LLM token-budget accumulator, stamped out as THREE owner-scope
+ * singleton variants from one polymorphic declaration (`userA2aTokenBudgetState` /
+ * `organizationA2aTokenBudgetState` / `applicationA2aTokenBudgetState`). Spread the
+ * produced factories into the registry factory map:
+ *   ...a2aTokenBudgetStatePolymorphicFactories
+ *
+ * Access model — SYSTEM-WRITTEN, OWNER-READABLE:
+ *   - This is internal enforcement state, not user-authored data: only the A2A runtime WRITES
+ *     it, via `*AsSystem` (governed by `systemAccessPolicy`). The tenant may READ its own row
+ *     (a usage view: "how much of my allowance have I used?"), but never authors it.
+ *   - CREATE (`INTERNAL_CALL` super-admin, no explicit request DTO — it auto-derives per variant so
+ *     the injected owner FK is required on the correct variant) opens the singleton on the first
+ *     budgeted turn, via `createAsSystem`. `INTERNAL_CALL` (not `REPOSITORY_ONLY`) is mandatory
+ *     here: `*AsSystem` dispatches through the service tier and resolves the op via
+ *     `getServiceOperationPathDefault`, which only matches INTERNAL_CALL / API_CALL variants.
+ *   - There is deliberately NO `UPDATE` operation. Advancing the counter is an ATOMIC increment
+ *     (`RepositoriesRegistryHandlerBackendService.atomicIncrementField`) executed at the repository
+ *     tier, precisely so concurrent turns cannot lose tokens to a read-modify-write race — a
+ *     service-tier UPDATE cannot express that. Declaring an `UPDATE` op (with a DTO and a
+ *     `systemAccessPolicy.update` grant) would therefore be dead configuration describing a write
+ *     path nothing takes, and would invite a future contributor to route the counter through it and
+ *     silently reintroduce the race.
+ *   - DELETE is `INTERNAL_CALL` super-admin: it exists to satisfy the composition `onParentDelete`
+ *     cascade teardown (which runs at the repository tier and selects the operation-default DELETE,
+ *     irrespective of variant type), NOT to offer an HTTP surface. Deliberately NOT `API_CALL`:
+ *     zeroing this row zeroes recorded consumption, which is a SPEND-CAP BYPASS, so it gets no URL
+ *     at all — strictly stronger than relying on a role floor. (The role floor is nevertheless
+ *     platform-only for defence in depth.)
+ *   - READ is the ONE `API_CALL`, and it is owner-level on its own merit: a tenant inspecting its
+ *     own consumption ("how much of my allowance have I used?"). It is read-only, so it cannot
+ *     affect the cap.
+ *
+ * CASCADE NOTE (recorded because it was initially mis-diagnosed): the cascade's requirement is a
+ * cardinality-appropriate DISCOVERY op + a DELETE teardown op — for a 1:1 child that is READ, for
+ * 1:many it is LIST. It does NOT require a URL-isable variant: `supportsOperation` checks only
+ * `isOperationDefault`, and a sole `INTERNAL_CALL` variant is the default within its own group.
+ * The guard violation seen while building this resource came from the relationship declaring
+ * `childCardinality: MANY` (the helper's default) on a SINGLETON — which demanded LIST, not READ.
+ * Fixing the cardinality fixed it; verified by reverting DELETE to `INTERNAL_CALL` with the guard
+ * still green.
+ *
+ * @see a2a-token-budget-state.shared.schemas.ts — the polymorphic declaration + base schema
+ * @see flows-actors-execution.shared.resources-config.schemas.ts — the 3-scope polymorphic config precedent
+ */
+import { CoreResourceOperation, CoreResourceType } from '../resources/resources.shared.core.definitions.js';
+import { ResourceOperationRiskLevel, ResourceOperationVariantType, } from '../resources/resources.shared.schemas.js';
+import { ResourceSystemAccessMode } from '../resources/resources-config.shared.schemas.js';
+import { createPolymorphicResourceConfigurations } from '../resources/utils/resource-polymorphism.factory.js';
+import { CORE_APP_ROLES, CORE_ORG_ROLES } from '../security/authorizations/roles.shared.schemas.js';
+import { a2aTokenBudgetStatePolymorphicDeclaration } from './a2a-token-budget-state.shared.schemas.js';
+import { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas.js';
+/**
+ * Per-variant OWNER-READ role map. A tenant may inspect its OWN budget consumption (a
+ * read-only usage view: "how much of my allowance have I used?"). The scope authorizer +
+ * contextual filter isolate rows to the owner; the role is the operation floor.
+ *
+ * The APPLICATION variant is intentionally `APP_USER`, matching the `flowActorExecutions`
+ * precedent: app-scope rows are app-wide state, so any authenticated app user can read the
+ * application's aggregate A2A consumption. Tighten to an admin role if that telemetry is ever
+ * considered sensitive — it reveals platform usage volume, not tenant content.
+ */
+const OWNER_READ_ROLES = {
+    [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_USER],
+    [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_MEMBER],
+    [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_USER],
+};
+/**
+ * Polymorphic factory map for the A2A token budget state. Spread into
+ * `coreShared_ResourcesConfigurations_FactoryMap`:
+ *   ...a2aTokenBudgetStatePolymorphicFactories
+ *
+ * Produces entries for:
+ *   - userA2aTokenBudgetState
+ *   - organizationA2aTokenBudgetState
+ *   - applicationA2aTokenBudgetState
+ */
+export const a2aTokenBudgetStatePolymorphicFactories = createPolymorphicResourceConfigurations(a2aTokenBudgetStatePolymorphicDeclaration, {
+    isSystemResource: true,
+    // Opt the A2A runtime (system actor) into scoped writes/reads on the tenant's behalf.
+    // Absent this, every `*AsSystem` verb fails closed. Shared by all variants.
+    // No `update` grant: the counter is advanced by an atomic repository-tier increment, never by
+    // `updateAsSystem` (see the header). Granting it would authorise a path nothing takes.
+    systemAccessPolicy: {
+        // Subject-export disclosure. The subject's own token-budget state. Secrets and backend-only values are withheld by the export's security floor regardless of this grant. On a polymorphic resource this grant applies to EVERY generated variant, which is the documented intent of the shared config.
+        exportSubject: ResourceSystemAccessMode.ALLOWED,
+        create: ResourceSystemAccessMode.ALLOWED,
+        read: ResourceSystemAccessMode.ALLOWED,
+    },
+    portabilityPolicy: { defaultProvenance: DataPortabilityProvenance.OBSERVED },
+    coreOperations: [
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.DELETE,
+    ],
+    operationsConfiguration: {
+        // === CREATE === runtime opens the singleton on the first budgeted turn (createAsSystem).
+        // No explicit request DTO: auto-derives per variant so the injected owner FK is required.
+        [CoreResourceOperation.CREATE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.INTERNAL_CALL,
+                    isDefault: true,
+                    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        // === READ === the owner inspects its own consumption AND the runtime loads the singleton
+        // for the pre-dispatch budget check (readAsSystem). `API_CALL` on its own merit — a
+        // tenant-facing usage view — and read-only, so owner-level roles cannot affect the cap. It
+        // ALSO serves as the cascade's 1:1 discovery op, though that would be satisfied by a
+        // non-URL variant too (see the CASCADE NOTE in the file header).
+        [CoreResourceOperation.READ]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    polymorphicRole: OWNER_READ_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        // (No UPDATE operation — the counter is advanced by an atomic repository-tier increment so
+        // concurrent turns cannot lose tokens to a read-modify-write race. See the file header.)
+        // === DELETE === teardown for the composition `onParentDelete` cascade (repository tier,
+        // which selects the operation-default DELETE regardless of variant type).
+        //
+        // ⚠️ DELIBERATELY `INTERNAL_CALL` — NO HTTP ROUTE AT ALL. Deleting this row ZEROES the
+        // tenant's recorded consumption, i.e. a SPEND-CAP BYPASS, so the strongest available
+        // protection is to expose no URL rather than to guard one with a role. The platform-only
+        // (`APP_ADMIN_SUPER_ADMIN`) floor is defence in depth on top of that. The cascade is
+        // unaffected: it runs below both routing and role checks.
+        [CoreResourceOperation.DELETE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.INTERNAL_CALL,
+                    isDefault: true,
+                    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+                    riskLevel: ResourceOperationRiskLevel.HIGH,
+                }],
+        },
+    },
+});
+//# sourceMappingURL=a2a-token-budget-state.shared.resources-config.schemas.js.map

package/dist/esm/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-token-budget-state.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-token-budget-state.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AACzG,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,uCAAuC,EAAE,MAAM,kDAAkD,CAAC;AAC3G,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACjG,OAAO,EAAE,yCAAyC,EAAE,MAAM,yCAAyC,CAAC;AACpG,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC;AAEhG;;;;;;;;;GASG;AACH,MAAM,gBAAgB,GAAG;IACvB,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC;IACnD,CAAC,gBAAgB,CAAC,aAAa,CAAC,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC;IAC7D,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC;CAC1D,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,uCAAuC,GAAG,uCAAuC,CAC5F,yCAAyC,EACzC;IACE,gBAAgB,EAAE,IAAI;IAEtB,sFAAsF;IACtF,4EAA4E;IAC5E,8FAA8F;IAC9F,uFAAuF;IACvF,kBAAkB,EAAE;QAClB,uSAAuS;QACvS,aAAa,EAAE,wBAAwB,CAAC,OAAO;QAC/C,MAAM,EAAE,wBAAwB,CAAC,OAAO;QACxC,IAAI,EAAE,wBAAwB,CAAC,OAAO;KACvC;IACD,iBAAiB,EAAE,EAAE,iBAAiB,EAAE,yBAAyB,CAAC,QAAQ,EAAE;IAE5E,cAAc,EAAE;QACd,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,MAAM;KAC7B;IAED,uBAAuB,EAAE;QACvB,0FAA0F;QAC1F,0FAA0F;QAC1F,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE;YAC9B,QAAQ,EAAE,CAAC;oBACT,WAAW,EAAE,4BAA4B,CAAC,aAAa;oBACvD,SAAS,EAAE,IAAI;oBACf,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;oBAC7C,SAAS,EAAE,0BAA0B,CAAC,GAAG;iBAC1C,CAAC;SACH;QAED,0FAA0F;QAC1F,oFAAoF;QACpF,2FAA2F;QAC3F,qFAAqF;QACrF,iEAAiE;QACjE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE;YAC5B,QAAQ,EAAE,CAAC;oBACT,WAAW,EAAE,4BAA4B,CAAC,QAAQ;oBAClD,SAAS,EAAE,IAAI;oBACf,eAAe,EAAE,gBAAgB;oBACjC,SAAS,EAAE,0BAA0B,CAAC,GAAG;iBAC1C,CAAC;SACH;QAED,2FAA2F;QAC3F,yFAAyF;QAEzF,yFAAyF;QACzF,0EAA0E;QAC1E,EAAE;QACF,uFAAuF;QACvF,qFAAqF;QACrF,yFAAyF;QACzF,qFAAqF;QACrF,0DAA0D;QAC1D,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE;YAC9B,QAAQ,EAAE,CAAC;oBACT,WAAW,EAAE,4BAA4B,CAAC,aAAa;oBACvD,SAAS,EAAE,IAAI;oBACf,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;oBAC7C,SAAS,EAAE,0BAA0B,CAAC,IAAI;iBAC3C,CAAC;SACH;KACF;CACF,CACF,CAAC","sourcesContent":["/**\n * A2A Token Budget State — Resource Configuration (POLYMORPHIC SINGLETON)\n * ======================================================================\n *\n * The per-tenant A2A LLM token-budget accumulator, stamped out as THREE owner-scope\n * singleton variants from one polymorphic declaration (`userA2aTokenBudgetState` /\n * `organizationA2aTokenBudgetState` / `applicationA2aTokenBudgetState`). Spread the\n * produced factories into the registry factory map:\n *   ...a2aTokenBudgetStatePolymorphicFactories\n *\n * Access model — SYSTEM-WRITTEN, OWNER-READABLE:\n *   - This is internal enforcement state, not user-authored data: only the A2A runtime WRITES\n *     it, via `*AsSystem` (governed by `systemAccessPolicy`). The tenant may READ its own row\n *     (a usage view: \"how much of my allowance have I used?\"), but never authors it.\n *   - CREATE (`INTERNAL_CALL` super-admin, no explicit request DTO — it auto-derives per variant so\n *     the injected owner FK is required on the correct variant) opens the singleton on the first\n *     budgeted turn, via `createAsSystem`. `INTERNAL_CALL` (not `REPOSITORY_ONLY`) is mandatory\n *     here: `*AsSystem` dispatches through the service tier and resolves the op via\n *     `getServiceOperationPathDefault`, which only matches INTERNAL_CALL / API_CALL variants.\n *   - There is deliberately NO `UPDATE` operation. Advancing the counter is an ATOMIC increment\n *     (`RepositoriesRegistryHandlerBackendService.atomicIncrementField`) executed at the repository\n *     tier, precisely so concurrent turns cannot lose tokens to a read-modify-write race — a\n *     service-tier UPDATE cannot express that. Declaring an `UPDATE` op (with a DTO and a\n *     `systemAccessPolicy.update` grant) would therefore be dead configuration describing a write\n *     path nothing takes, and would invite a future contributor to route the counter through it and\n *     silently reintroduce the race.\n *   - DELETE is `INTERNAL_CALL` super-admin: it exists to satisfy the composition `onParentDelete`\n *     cascade teardown (which runs at the repository tier and selects the operation-default DELETE,\n *     irrespective of variant type), NOT to offer an HTTP surface. Deliberately NOT `API_CALL`:\n *     zeroing this row zeroes recorded consumption, which is a SPEND-CAP BYPASS, so it gets no URL\n *     at all — strictly stronger than relying on a role floor. (The role floor is nevertheless\n *     platform-only for defence in depth.)\n *   - READ is the ONE `API_CALL`, and it is owner-level on its own merit: a tenant inspecting its\n *     own consumption (\"how much of my allowance have I used?\"). It is read-only, so it cannot\n *     affect the cap.\n *\n * CASCADE NOTE (recorded because it was initially mis-diagnosed): the cascade's requirement is a\n * cardinality-appropriate DISCOVERY op + a DELETE teardown op — for a 1:1 child that is READ, for\n * 1:many it is LIST. It does NOT require a URL-isable variant: `supportsOperation` checks only\n * `isOperationDefault`, and a sole `INTERNAL_CALL` variant is the default within its own group.\n * The guard violation seen while building this resource came from the relationship declaring\n * `childCardinality: MANY` (the helper's default) on a SINGLETON — which demanded LIST, not READ.\n * Fixing the cardinality fixed it; verified by reverting DELETE to `INTERNAL_CALL` with the guard\n * still green.\n *\n * @see a2a-token-budget-state.shared.schemas.ts — the polymorphic declaration + base schema\n * @see flows-actors-execution.shared.resources-config.schemas.ts — the 3-scope polymorphic config precedent\n */\n\nimport { CoreResourceOperation, CoreResourceType } from '../resources/resources.shared.core.definitions';\nimport {\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n} from '../resources/resources.shared.schemas';\nimport { ResourceSystemAccessMode } from '../resources/resources-config.shared.schemas';\nimport { createPolymorphicResourceConfigurations } from '../resources/utils/resource-polymorphism.factory';\nimport { CORE_APP_ROLES, CORE_ORG_ROLES } from '../security/authorizations/roles.shared.schemas';\nimport { a2aTokenBudgetStatePolymorphicDeclaration } from './a2a-token-budget-state.shared.schemas';\nimport { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas';\n\n/**\n * Per-variant OWNER-READ role map. A tenant may inspect its OWN budget consumption (a\n * read-only usage view: \"how much of my allowance have I used?\"). The scope authorizer +\n * contextual filter isolate rows to the owner; the role is the operation floor.\n *\n * The APPLICATION variant is intentionally `APP_USER`, matching the `flowActorExecutions`\n * precedent: app-scope rows are app-wide state, so any authenticated app user can read the\n * application's aggregate A2A consumption. Tighten to an admin role if that telemetry is ever\n * considered sensitive — it reveals platform usage volume, not tenant content.\n */\nconst OWNER_READ_ROLES = {\n  [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_USER],\n  [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_MEMBER],\n  [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_USER],\n};\n\n/**\n * Polymorphic factory map for the A2A token budget state. Spread into\n * `coreShared_ResourcesConfigurations_FactoryMap`:\n *   ...a2aTokenBudgetStatePolymorphicFactories\n *\n * Produces entries for:\n *   - userA2aTokenBudgetState\n *   - organizationA2aTokenBudgetState\n *   - applicationA2aTokenBudgetState\n */\nexport const a2aTokenBudgetStatePolymorphicFactories = createPolymorphicResourceConfigurations(\n  a2aTokenBudgetStatePolymorphicDeclaration,\n  {\n    isSystemResource: true,\n\n    // Opt the A2A runtime (system actor) into scoped writes/reads on the tenant's behalf.\n    // Absent this, every `*AsSystem` verb fails closed. Shared by all variants.\n    // No `update` grant: the counter is advanced by an atomic repository-tier increment, never by\n    // `updateAsSystem` (see the header). Granting it would authorise a path nothing takes.\n    systemAccessPolicy: {\n      // Subject-export disclosure. The subject's own token-budget state. Secrets and backend-only values are withheld by the export's security floor regardless of this grant. On a polymorphic resource this grant applies to EVERY generated variant, which is the documented intent of the shared config.\n      exportSubject: ResourceSystemAccessMode.ALLOWED,\n      create: ResourceSystemAccessMode.ALLOWED,\n      read: ResourceSystemAccessMode.ALLOWED,\n    },\n    portabilityPolicy: { defaultProvenance: DataPortabilityProvenance.OBSERVED },\n\n    coreOperations: [\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.READ,\n      CoreResourceOperation.DELETE,\n    ],\n\n    operationsConfiguration: {\n      // === CREATE === runtime opens the singleton on the first budgeted turn (createAsSystem).\n      // No explicit request DTO: auto-derives per variant so the injected owner FK is required.\n      [CoreResourceOperation.CREATE]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.INTERNAL_CALL,\n          isDefault: true,\n          roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n\n      // === READ === the owner inspects its own consumption AND the runtime loads the singleton\n      // for the pre-dispatch budget check (readAsSystem). `API_CALL` on its own merit — a\n      // tenant-facing usage view — and read-only, so owner-level roles cannot affect the cap. It\n      // ALSO serves as the cascade's 1:1 discovery op, though that would be satisfied by a\n      // non-URL variant too (see the CASCADE NOTE in the file header).\n      [CoreResourceOperation.READ]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.API_CALL,\n          isDefault: true,\n          polymorphicRole: OWNER_READ_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n\n      // (No UPDATE operation — the counter is advanced by an atomic repository-tier increment so\n      // concurrent turns cannot lose tokens to a read-modify-write race. See the file header.)\n\n      // === DELETE === teardown for the composition `onParentDelete` cascade (repository tier,\n      // which selects the operation-default DELETE regardless of variant type).\n      //\n      // ⚠️ DELIBERATELY `INTERNAL_CALL` — NO HTTP ROUTE AT ALL. Deleting this row ZEROES the\n      // tenant's recorded consumption, i.e. a SPEND-CAP BYPASS, so the strongest available\n      // protection is to expose no URL rather than to guard one with a role. The platform-only\n      // (`APP_ADMIN_SUPER_ADMIN`) floor is defence in depth on top of that. The cascade is\n      // unaffected: it runs below both routing and role checks.\n      [CoreResourceOperation.DELETE]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.INTERNAL_CALL,\n          isDefault: true,\n          roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n          riskLevel: ResourceOperationRiskLevel.HIGH,\n        }],\n      },\n    },\n  },\n);\n"]}

package/dist/esm/flows-actors/a2a-token-budget-state.shared.schemas.d.ts

@@ -0,0 +1,77 @@
+/**
+ * A2A Token Budget State — Persisted Resource Schema (POLYMORPHIC SINGLETON)
+ * ==========================================================================
+ *
+ * The durable per-tenant accumulator that enforces a per-period LLM **token budget**
+ * on inbound Agent2Agent (A2A) agent turns. Each A2A turn runs the LLM runtime; this
+ * record holds how many tokens the tenant has consumed IN THE CURRENT PERIOD, so the
+ * A2A transport can fail-closed BEFORE dispatch once the plan allowance is reached.
+ *
+ * WHY A DEDICATED RESOURCE (not `UsageRecord`, not `CreditPool`): a plan-included token
+ * ALLOWANCE is a genuinely distinct concept from metered pay-per-use (`UsageRecord`, which
+ * is metered-subscription-gated) and from a prepaid credit pack (`CreditPool`). Conflating
+ * them would bend those semantics; this resource owns exactly one concern — period token
+ * accounting for enforcement. The plan ALLOWANCE itself is NOT stored here — it is resolved
+ * live from the billing plan (`FeatureResolution.resolveForScope(...).limits[featureId]`);
+ * this record only accumulates CONSUMPTION.
+ *
+ * POLYMORPHIC SINGLETON ACROSS OWNER SCOPE. One row per tenant, stamped out as THREE
+ * genuine single-scope resources by `declarePolymorphicSchemas()`, one owner FK injected
+ * per variant (mirrors the flows-actors-execution / billing-account precedent):
+ *   - `userA2aTokenBudgetState`         (USER_SELF     — `userId`)         ← user-delegated A2A
+ *   - `organizationA2aTokenBudgetState` (ORGANIZATIONS — `organizationId`) ← org-machine A2A
+ *   - `applicationA2aTokenBudgetState`  (APPLICATION   — `applicationId`)  ← app-machine A2A
+ *
+ * SINGLETON, DELIBERATELY: the injected owner FK is the auto business key (`.isUnique()`,
+ * ONE row per tenant) — we do NOT `optOutPolymorphicAutoBusinessKey` (that is for multi-row
+ * collections). One row per tenant is what keeps the counter un-splittable (no compound-key
+ * engineering), and the period ROLLOVER is a mutation of that single row (reset
+ * `consumedTokens` when `periodKey` changes), owned atomically by the accumulator service.
+ * Per-period HISTORY and multi-budget-feature accounting are documented follow-ons — v1
+ * enforces a single A2A token budget and only needs the current period.
+ *
+ * ⚠️ ADAPTER CAVEAT — that uniqueness is DB-ENFORCED ONLY ON MONGODB. `.isUnique()` compiles
+ * to a Mongo unique index; the SQL planner emits no unique constraint (index creation there is
+ * migration-owned). On PostgreSQL two concurrent first-ever turns can therefore each insert a
+ * row, after which consumption is SPLIT across them while reads see only one — under-reported
+ * spend, and a cap that fires late. The accumulator's create-race fallback repairs the common
+ * interleaving (a rejected create falls through to an increment) but cannot repair what the
+ * database never rejected. Closing this properly needs a unique constraint on the owner FK in
+ * the PostgreSQL migration for each variant table.
+ *
+ * @see flows-actors-execution.shared.schemas.ts — the 3-scope polymorphic precedent
+ * @see billing-account.shared.schemas.ts — the polymorphic-singleton precedent
+ */
+import { z } from 'zod';
+import { type PolymorphicVariantDefinition } from '../resources/utils/resource-polymorphism.schemas';
+export declare const A2ATokenBudgetStateSchema: z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    periodKey: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    consumedTokens: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNumber>>;
+    lastTurnAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>;
+export type A2ATokenBudgetState = z.infer<typeof A2ATokenBudgetStateSchema>;
+/**
+ * The three owner-scope variants the A2A token budget is stamped out for. Each is
+ * `isPrimaryScope: true` and — unlike the multi-row flows-actors executions — does NOT opt
+ * out of the singleton auto-business-key: the injected owner FK IS the business key, so there
+ * is exactly ONE budget row per tenant (the period lives inside that row).
+ */
+export declare const A2A_TOKEN_BUDGET_SCOPE_VARIANTS: PolymorphicVariantDefinition[];
+/**
+ * Polymorphic declaration for the A2A token budget state. Produces 3 singleton variants:
+ *   - users        → `userA2aTokenBudgetState`         (`userId` injected)
+ *   - organizations→ `organizationA2aTokenBudgetState` (`organizationId` injected)
+ *   - applications → `applicationA2aTokenBudgetState`  (`applicationId` injected)
+ */
+export declare const a2aTokenBudgetStatePolymorphicDeclaration: import("..").PolymorphicSchemaDeclaration<z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    periodKey: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    consumedTokens: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNumber>>;
+    lastTurnAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>>;
+//# sourceMappingURL=a2a-token-budget-state.shared.schemas.d.ts.map

package/dist/esm/flows-actors/a2a-token-budget-state.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-token-budget-state.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-token-budget-state.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,kDAAkD,CAAC;AAI1D,eAAO,MAAM,yBAAyB;;;;;;;iBAwBpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,EAAE,4BAA4B,EAIzE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC;;;;;;;kBAMpD,CAAC"}

package/dist/esm/flows-actors/a2a-token-budget-state.shared.schemas.js

@@ -0,0 +1,103 @@
+/**
+ * A2A Token Budget State — Persisted Resource Schema (POLYMORPHIC SINGLETON)
+ * ==========================================================================
+ *
+ * The durable per-tenant accumulator that enforces a per-period LLM **token budget**
+ * on inbound Agent2Agent (A2A) agent turns. Each A2A turn runs the LLM runtime; this
+ * record holds how many tokens the tenant has consumed IN THE CURRENT PERIOD, so the
+ * A2A transport can fail-closed BEFORE dispatch once the plan allowance is reached.
+ *
+ * WHY A DEDICATED RESOURCE (not `UsageRecord`, not `CreditPool`): a plan-included token
+ * ALLOWANCE is a genuinely distinct concept from metered pay-per-use (`UsageRecord`, which
+ * is metered-subscription-gated) and from a prepaid credit pack (`CreditPool`). Conflating
+ * them would bend those semantics; this resource owns exactly one concern — period token
+ * accounting for enforcement. The plan ALLOWANCE itself is NOT stored here — it is resolved
+ * live from the billing plan (`FeatureResolution.resolveForScope(...).limits[featureId]`);
+ * this record only accumulates CONSUMPTION.
+ *
+ * POLYMORPHIC SINGLETON ACROSS OWNER SCOPE. One row per tenant, stamped out as THREE
+ * genuine single-scope resources by `declarePolymorphicSchemas()`, one owner FK injected
+ * per variant (mirrors the flows-actors-execution / billing-account precedent):
+ *   - `userA2aTokenBudgetState`         (USER_SELF     — `userId`)         ← user-delegated A2A
+ *   - `organizationA2aTokenBudgetState` (ORGANIZATIONS — `organizationId`) ← org-machine A2A
+ *   - `applicationA2aTokenBudgetState`  (APPLICATION   — `applicationId`)  ← app-machine A2A
+ *
+ * SINGLETON, DELIBERATELY: the injected owner FK is the auto business key (`.isUnique()`,
+ * ONE row per tenant) — we do NOT `optOutPolymorphicAutoBusinessKey` (that is for multi-row
+ * collections). One row per tenant is what keeps the counter un-splittable (no compound-key
+ * engineering), and the period ROLLOVER is a mutation of that single row (reset
+ * `consumedTokens` when `periodKey` changes), owned atomically by the accumulator service.
+ * Per-period HISTORY and multi-budget-feature accounting are documented follow-ons — v1
+ * enforces a single A2A token budget and only needs the current period.
+ *
+ * ⚠️ ADAPTER CAVEAT — that uniqueness is DB-ENFORCED ONLY ON MONGODB. `.isUnique()` compiles
+ * to a Mongo unique index; the SQL planner emits no unique constraint (index creation there is
+ * migration-owned). On PostgreSQL two concurrent first-ever turns can therefore each insert a
+ * row, after which consumption is SPLIT across them while reads see only one — under-reported
+ * spend, and a cap that fires late. The accumulator's create-race fallback repairs the common
+ * interleaving (a rejected create falls through to an increment) but cannot repair what the
+ * database never rejected. Closing this properly needs a unique constraint on the owner FK in
+ * the PostgreSQL migration for each variant table.
+ *
+ * @see flows-actors-execution.shared.schemas.ts — the 3-scope polymorphic precedent
+ * @see billing-account.shared.schemas.ts — the polymorphic-singleton precedent
+ */
+import { z } from 'zod';
+import { initZodDecorators } from '@wildo-ai/zod-decorators';
+import { CoreResourceType, coreResourceShared_FieldIdentifier, } from '../resources/resources.shared.core.definitions.js';
+import { declarePolymorphicSchemas, } from '../resources/utils/resource-polymorphism.schemas.js';
+initZodDecorators(z);
+export const A2ATokenBudgetStateSchema = z.object({
+    /** MongoDB document id — auto-generated / auto-managed (excluded from create). */
+    _id: z.string().min(1).isPrimaryKey(),
+    /**
+     * The budget PERIOD this counter currently covers — a stable string id for the active
+     * window (e.g. the subscription period id, or a `YYYY-MM` calendar key). The reset
+     * boundary: when the resolved current period differs from this value, the accumulator
+     * service resets `consumedTokens` to the new turn's tokens and advances `periodKey`.
+     */
+    periodKey: z.string().min(1).isDBIndexed().isSummaryField(),
+    /**
+     * Tokens (prompt + completion) consumed by this tenant's A2A agent turns IN THE CURRENT
+     * period (`periodKey`). Compared against the plan allowance (resolved live) to fail-closed
+     * before dispatch. Reset to 0 (then incremented) when the period rolls.
+     */
+    consumedTokens: z.number().min(0).default(0).isSummaryField(),
+    /** When the last A2A turn was recorded against this budget (observability). */
+    lastTurnAt: z.date().optional().isSummaryField(),
+    createdAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),
+    updatedAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),
+});
+//===============================================================
+//  Polymorphic declaration — one owner-scope SINGLETON per scope
+//===============================================================
+/**
+ * The three owner-scope variants the A2A token budget is stamped out for. Each is
+ * `isPrimaryScope: true` and — unlike the multi-row flows-actors executions — does NOT opt
+ * out of the singleton auto-business-key: the injected owner FK IS the business key, so there
+ * is exactly ONE budget row per tenant (the period lives inside that row).
+ */
+export const A2A_TOKEN_BUDGET_SCOPE_VARIANTS = [
+    { parentResourceType: CoreResourceType.USERS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.USERS], isPrimaryScope: true },
+    { parentResourceType: CoreResourceType.ORGANIZATIONS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS], isPrimaryScope: true },
+    { parentResourceType: CoreResourceType.APPLICATION, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.APPLICATION], isPrimaryScope: true },
+];
+/**
+ * Polymorphic declaration for the A2A token budget state. Produces 3 singleton variants:
+ *   - users        → `userA2aTokenBudgetState`         (`userId` injected)
+ *   - organizations→ `organizationA2aTokenBudgetState` (`organizationId` injected)
+ *   - applications → `applicationA2aTokenBudgetState`  (`applicationId` injected)
+ */
+export const a2aTokenBudgetStatePolymorphicDeclaration = declarePolymorphicSchemas({
+    baseResourceType: 'a2aTokenBudgetState',
+    baseFieldIdentifier: 'a2aTokenBudgetStateId',
+    baseEnumKey: 'A2A_TOKEN_BUDGET_STATE',
+    baseSchema: A2ATokenBudgetStateSchema,
+    variants: A2A_TOKEN_BUDGET_SCOPE_VARIANTS,
+});
+// NOTE: there is deliberately NO update DTO for this resource. The counter is advanced by an
+// ATOMIC repository-tier increment (`atomicIncrementField`) rather than a service-tier UPDATE,
+// precisely so concurrent turns cannot lose tokens to a read-modify-write race. A DTO here would
+// describe a write path nothing takes — and would invite routing the counter through it, silently
+// reintroducing that race. See `a2a-token-budget-state.shared.resources-config.schemas.ts`.
+//# sourceMappingURL=a2a-token-budget-state.shared.schemas.js.map

package/dist/esm/flows-actors/a2a-token-budget-state.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-token-budget-state.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-token-budget-state.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EACL,gBAAgB,EAChB,kCAAkC,GACnC,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,yBAAyB,GAE1B,MAAM,kDAAkD,CAAC;AAE1D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,kFAAkF;IAClF,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE;IAErC;;;;;OAKG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAE3D;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE;IAE7D,+EAA+E;IAC/E,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,cAAc,EAAE;IAEhD,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,iBAAiB,EAAE,CAAC,iBAAiB,EAAE;IACrF,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,iBAAiB,EAAE,CAAC,iBAAiB,EAAE;CACtF,CAAC,CAAC;AAGH,iEAAiE;AACjE,iEAAiE;AACjE,iEAAiE;AAEjE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAmC;IAC7E,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,KAAK,EAAU,qBAAqB,EAAE,kCAAkC,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAU,cAAc,EAAE,IAAI,EAAE;IACvK,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,aAAa,EAAE,qBAAqB,EAAE,kCAAkC,CAAC,gBAAgB,CAAC,aAAa,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE;IACvK,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,WAAW,EAAI,qBAAqB,EAAE,kCAAkC,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAI,cAAc,EAAE,IAAI,EAAE;CACxK,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yCAAyC,GAAG,yBAAyB,CAAC;IACjF,gBAAgB,EAAE,qBAAqB;IACvC,mBAAmB,EAAE,uBAAuB;IAC5C,WAAW,EAAE,wBAAwB;IACrC,UAAU,EAAE,yBAAyB;IACrC,QAAQ,EAAE,+BAA+B;CAC1C,CAAC,CAAC;AAEH,6FAA6F;AAC7F,+FAA+F;AAC/F,iGAAiG;AACjG,kGAAkG;AAClG,4FAA4F","sourcesContent":["/**\n * A2A Token Budget State — Persisted Resource Schema (POLYMORPHIC SINGLETON)\n * ==========================================================================\n *\n * The durable per-tenant accumulator that enforces a per-period LLM **token budget**\n * on inbound Agent2Agent (A2A) agent turns. Each A2A turn runs the LLM runtime; this\n * record holds how many tokens the tenant has consumed IN THE CURRENT PERIOD, so the\n * A2A transport can fail-closed BEFORE dispatch once the plan allowance is reached.\n *\n * WHY A DEDICATED RESOURCE (not `UsageRecord`, not `CreditPool`): a plan-included token\n * ALLOWANCE is a genuinely distinct concept from metered pay-per-use (`UsageRecord`, which\n * is metered-subscription-gated) and from a prepaid credit pack (`CreditPool`). Conflating\n * them would bend those semantics; this resource owns exactly one concern — period token\n * accounting for enforcement. The plan ALLOWANCE itself is NOT stored here — it is resolved\n * live from the billing plan (`FeatureResolution.resolveForScope(...).limits[featureId]`);\n * this record only accumulates CONSUMPTION.\n *\n * POLYMORPHIC SINGLETON ACROSS OWNER SCOPE. One row per tenant, stamped out as THREE\n * genuine single-scope resources by `declarePolymorphicSchemas()`, one owner FK injected\n * per variant (mirrors the flows-actors-execution / billing-account precedent):\n *   - `userA2aTokenBudgetState`         (USER_SELF     — `userId`)         ← user-delegated A2A\n *   - `organizationA2aTokenBudgetState` (ORGANIZATIONS — `organizationId`) ← org-machine A2A\n *   - `applicationA2aTokenBudgetState`  (APPLICATION   — `applicationId`)  ← app-machine A2A\n *\n * SINGLETON, DELIBERATELY: the injected owner FK is the auto business key (`.isUnique()`,\n * ONE row per tenant) — we do NOT `optOutPolymorphicAutoBusinessKey` (that is for multi-row\n * collections). One row per tenant is what keeps the counter un-splittable (no compound-key\n * engineering), and the period ROLLOVER is a mutation of that single row (reset\n * `consumedTokens` when `periodKey` changes), owned atomically by the accumulator service.\n * Per-period HISTORY and multi-budget-feature accounting are documented follow-ons — v1\n * enforces a single A2A token budget and only needs the current period.\n *\n * ⚠️ ADAPTER CAVEAT — that uniqueness is DB-ENFORCED ONLY ON MONGODB. `.isUnique()` compiles\n * to a Mongo unique index; the SQL planner emits no unique constraint (index creation there is\n * migration-owned). On PostgreSQL two concurrent first-ever turns can therefore each insert a\n * row, after which consumption is SPLIT across them while reads see only one — under-reported\n * spend, and a cap that fires late. The accumulator's create-race fallback repairs the common\n * interleaving (a rejected create falls through to an increment) but cannot repair what the\n * database never rejected. Closing this properly needs a unique constraint on the owner FK in\n * the PostgreSQL migration for each variant table.\n *\n * @see flows-actors-execution.shared.schemas.ts — the 3-scope polymorphic precedent\n * @see billing-account.shared.schemas.ts — the polymorphic-singleton precedent\n */\n\nimport { z } from 'zod';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\nimport {\n  CoreResourceType,\n  coreResourceShared_FieldIdentifier,\n} from '../resources/resources.shared.core.definitions';\nimport {\n  declarePolymorphicSchemas,\n  type PolymorphicVariantDefinition,\n} from '../resources/utils/resource-polymorphism.schemas';\n\ninitZodDecorators(z);\n\nexport const A2ATokenBudgetStateSchema = z.object({\n  /** MongoDB document id — auto-generated / auto-managed (excluded from create). */\n  _id: z.string().min(1).isPrimaryKey(),\n\n  /**\n   * The budget PERIOD this counter currently covers — a stable string id for the active\n   * window (e.g. the subscription period id, or a `YYYY-MM` calendar key). The reset\n   * boundary: when the resolved current period differs from this value, the accumulator\n   * service resets `consumedTokens` to the new turn's tokens and advances `periodKey`.\n   */\n  periodKey: z.string().min(1).isDBIndexed().isSummaryField(),\n\n  /**\n   * Tokens (prompt + completion) consumed by this tenant's A2A agent turns IN THE CURRENT\n   * period (`periodKey`). Compared against the plan allowance (resolved live) to fail-closed\n   * before dispatch. Reset to 0 (then incremented) when the period rolls.\n   */\n  consumedTokens: z.number().min(0).default(0).isSummaryField(),\n\n  /** When the last A2A turn was recorded against this budget (observability). */\n  lastTurnAt: z.date().optional().isSummaryField(),\n\n  createdAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),\n  updatedAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),\n});\nexport type A2ATokenBudgetState = z.infer<typeof A2ATokenBudgetStateSchema>;\n\n//===============================================================\n//  Polymorphic declaration — one owner-scope SINGLETON per scope\n//===============================================================\n\n/**\n * The three owner-scope variants the A2A token budget is stamped out for. Each is\n * `isPrimaryScope: true` and — unlike the multi-row flows-actors executions — does NOT opt\n * out of the singleton auto-business-key: the injected owner FK IS the business key, so there\n * is exactly ONE budget row per tenant (the period lives inside that row).\n */\nexport const A2A_TOKEN_BUDGET_SCOPE_VARIANTS: PolymorphicVariantDefinition[] = [\n  { parentResourceType: CoreResourceType.USERS,         parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.USERS],         isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.ORGANIZATIONS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS], isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.APPLICATION,   parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.APPLICATION],   isPrimaryScope: true },\n];\n\n/**\n * Polymorphic declaration for the A2A token budget state. Produces 3 singleton variants:\n *   - users        → `userA2aTokenBudgetState`         (`userId` injected)\n *   - organizations→ `organizationA2aTokenBudgetState` (`organizationId` injected)\n *   - applications → `applicationA2aTokenBudgetState`  (`applicationId` injected)\n */\nexport const a2aTokenBudgetStatePolymorphicDeclaration = declarePolymorphicSchemas({\n  baseResourceType: 'a2aTokenBudgetState',\n  baseFieldIdentifier: 'a2aTokenBudgetStateId',\n  baseEnumKey: 'A2A_TOKEN_BUDGET_STATE',\n  baseSchema: A2ATokenBudgetStateSchema,\n  variants: A2A_TOKEN_BUDGET_SCOPE_VARIANTS,\n});\n\n// NOTE: there is deliberately NO update DTO for this resource. The counter is advanced by an\n// ATOMIC repository-tier increment (`atomicIncrementField`) rather than a service-tier UPDATE,\n// precisely so concurrent turns cannot lose tokens to a read-modify-write race. A DTO here would\n// describe a write path nothing takes — and would invite routing the counter through it, silently\n// reintroducing that race. See `a2a-token-budget-state.shared.resources-config.schemas.ts`.\n"]}