@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/jobs/ai-job-admission.js

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { AI_OFF_FOR_SITE_COPY, AI_OFF_FOR_SITE_STATUS, isAiOffForSite } from "../model/ai-site-switch.js";
+const admissions = new Map();
+/** Idempotent per kind; the last registration wins, and `null` unregisters. */ export function registerAiJobAdmission(kind, admission) {
+    if (admission) admissions.set(kind, admission);
+    else admissions.delete(kind);
+}
+/** The kind's registered admission, or `null` when it has none. */ export function aiJobAdmissionFor(kind) {
+    var _admissions_get;
+    return (_admissions_get = admissions.get(kind)) != null ? _admissions_get : null;
+}
+/** The kind's refusal, or `null` when it admits the job or has nothing to check. */ export async function aiJobAdmissionRefusal(kind, context) {
+    const admission = admissions.get(kind);
+    return admission ? admission(context) : null;
+}
+/**
+ * The refusal for a job on a site that switched AI off (AGL-3028), or `null`.
+ *
+ * Every kind meets it, and every door asks it BEFORE the kind's own check —
+ * the create door, each site of an agency batch, and a resume — so no job
+ * comes to exist, or runs another step, for a site that said no, and a
+ * switched-off site never pays for a kind's reads. A job with no site is
+ * workspace-level and always passes.
+ */ export async function aiJobSiteRefusal(context) {
+    return await isAiOffForSite(context.firestore, context.org, context.hostId) ? {
+        status: AI_OFF_FOR_SITE_STATUS,
+        error: AI_OFF_FOR_SITE_COPY
+    } : null;
+}
+
+//# sourceMappingURL=ai-job-admission.js.map

package/src/lib/jobs/ai-job-admission.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/jobs/ai-job-admission.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { AiJobKind, AiJobPlan } from '../model/ai-jobs.types'\nimport {\n  AI_OFF_FOR_SITE_COPY,\n  AI_OFF_FOR_SITE_STATUS,\n  isAiOffForSite,\n} from '../model/ai-site-switch'\n\n/**\n * What a job kind checks before a job of it runs (AGL-2909).\n *\n * The create door parses the body every kind shares — the org, the site, the\n * brief, scalar inputs — and nothing the machine knows says whether THIS kind\n * can finish: a layout needs a site to write to, a page template names the\n * collection it renders, and both write a document the site's plan counts.\n * A job that cannot finish should never start, because a planned kind spends\n * on its plan before it writes anything. So a kind registers one check, the\n * create door asks it after the gate ladder admitted the request and before\n * the job exists, and the resume door asks it again before a confirmed plan\n * runs, since an allowance free at creation may be used by now. Either way\n * a refusal hands the reservation back and spends nothing.\n *\n * The resume door also hands the check the plan being confirmed (AGL-2907),\n * so a kind that can build only some plans — a page job builds one screen\n * from what the site has — refuses the others when a member confirms them,\n * not a beat later from inside the step.\n *\n * The registry lives apart from the machine so the doors read it without the\n * generators, and a generator registers here beside its runner.\n */\n\nexport interface AiJobAdmissionContext {\n  /** The Admin SDK handle the door runs on. */\n  firestore: FirebaseFirestore.Firestore\n  orgId: string\n  hostId: string | null\n  /** The job's kind-specific inputs, as the door parsed or the job stored them. */\n  inputs: Readonly<Record<string, unknown>>\n  /** The org document the gate ladder read; a check narrows it to the fields it reads. */\n  org: object | null\n  /**\n   * The job's plan when the door is resuming a job that has one; absent at\n   * creation, when no plan exists yet.\n   */\n  plan?: AiJobPlan | null\n  /**\n   * The member whose request spends: the creator at the create door, the\n   * member confirming at the resume door. A kind whose draft another plugin\n   * writes asks that plugin whether this member may create one.\n   */\n  uid?: string | null\n}\n\nexport interface AiJobAdmissionRefusal {\n  status: 400 | 403 | 404\n  /** Customer-safe: the door answers with it as it stands. */\n  error: string\n}\n\nexport type AiJobAdmission = (\n  context: AiJobAdmissionContext,\n) => Promise<AiJobAdmissionRefusal | null>\n\nconst admissions = new Map<AiJobKind, AiJobAdmission>()\n\n/** Idempotent per kind; the last registration wins, and `null` unregisters. */\nexport function registerAiJobAdmission(kind: AiJobKind, admission: AiJobAdmission | null): void {\n  if (admission) admissions.set(kind, admission)\n  else admissions.delete(kind)\n}\n\n/** The kind's registered admission, or `null` when it has none. */\nexport function aiJobAdmissionFor(kind: AiJobKind): AiJobAdmission | null {\n  return admissions.get(kind) ?? null\n}\n\n/** The kind's refusal, or `null` when it admits the job or has nothing to check. */\nexport async function aiJobAdmissionRefusal(\n  kind: AiJobKind,\n  context: AiJobAdmissionContext,\n): Promise<AiJobAdmissionRefusal | null> {\n  const admission = admissions.get(kind)\n  return admission ? admission(context) : null\n}\n\n/**\n * The refusal for a job on a site that switched AI off (AGL-3028), or `null`.\n *\n * Every kind meets it, and every door asks it BEFORE the kind's own check —\n * the create door, each site of an agency batch, and a resume — so no job\n * comes to exist, or runs another step, for a site that said no, and a\n * switched-off site never pays for a kind's reads. A job with no site is\n * workspace-level and always passes.\n */\nexport async function aiJobSiteRefusal(\n  context: Pick<AiJobAdmissionContext, 'firestore' | 'org' | 'hostId'>,\n): Promise<AiJobAdmissionRefusal | null> {\n  return (await isAiOffForSite(context.firestore, context.org, context.hostId))\n    ? { status: AI_OFF_FOR_SITE_STATUS, error: AI_OFF_FOR_SITE_COPY }\n    : null\n}\n"],"names":["AI_OFF_FOR_SITE_COPY","AI_OFF_FOR_SITE_STATUS","isAiOffForSite","admissions","Map","registerAiJobAdmission","kind","admission","set","delete","aiJobAdmissionFor","get","aiJobAdmissionRefusal","context","aiJobSiteRefusal","firestore","org","hostId","status","error"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SACEA,oBAAoB,EACpBC,sBAAsB,EACtBC,cAAc,QACT,6BAAyB;AAyDhC,MAAMC,aAAa,IAAIC;AAEvB,6EAA6E,GAC7E,OAAO,SAASC,uBAAuBC,IAAe,EAAEC,SAAgC;IACtF,IAAIA,WAAWJ,WAAWK,GAAG,CAACF,MAAMC;SAC/BJ,WAAWM,MAAM,CAACH;AACzB;AAEA,iEAAiE,GACjE,OAAO,SAASI,kBAAkBJ,IAAe;QACxCH;IAAP,QAAOA,kBAAAA,WAAWQ,GAAG,CAACL,iBAAfH,kBAAwB;AACjC;AAEA,kFAAkF,GAClF,OAAO,eAAeS,sBACpBN,IAAe,EACfO,OAA8B;IAE9B,MAAMN,YAAYJ,WAAWQ,GAAG,CAACL;IACjC,OAAOC,YAAYA,UAAUM,WAAW;AAC1C;AAEA;;;;;;;;CAQC,GACD,OAAO,eAAeC,iBACpBD,OAAoE;IAEpE,OAAO,AAAC,MAAMX,eAAeW,QAAQE,SAAS,EAAEF,QAAQG,GAAG,EAAEH,QAAQI,MAAM,IACvE;QAAEC,QAAQjB;QAAwBkB,OAAOnB;IAAqB,IAC9D;AACN"}

package/src/lib/jobs/ai-job-budget.d.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type AiCatalogEntry } from '../providers/catalog';
+/**
+ * How long a generation takes, planned from what one answer costs in time
+ * (AGL-2907), so a step that generates can say how much time it needs before
+ * it starts.
+ *
+ * The job machine gives a step what is left of its caller's budget as an
+ * abort signal: the beat's sweep, or an inline door. A provider call that
+ * signal cuts off is still generated and billed upstream, while the meter
+ * records nothing. So a generation step registers the least time it needs
+ * (`registerAiJobStep(kind, runner, { minimumMs })`), and sizes its answer so
+ * its worst case — every model call it may make answered at its ceiling —
+ * fits inside that.
+ *
+ * ── Every model call, not only the answers (AGL-3036) ────────────────────
+ *
+ * A generation offered the site inventory may spend up to
+ * `AI_INVENTORY_LOOKUP_MAX_ROUNDS` model calls looking records up before it
+ * answers, each asked at the answer's ceiling. The doctrine's loop holds the
+ * whole generation — lookups, answer and re-ask — to one allowance of output,
+ * `AI_GENERATION_MAX_ATTEMPTS` times the ceiling, and asks each call for no
+ * more than is left of it. So the worst case is every call's wait for a first
+ * token, plus that allowance at the assumed rate, plus the step's own reads
+ * and writes: a lookup round adds a wait, and the output it spends is output
+ * no answer can.
+ *
+ * ── Declared assumptions, not measurements ───────────────────────────────
+ *
+ * No spec can time a provider, and no recorded run has measured one, so the
+ * two rates below are assumptions the budget is planned against, named as
+ * such here and in `docs/AI_JOBS.md`. They err slow: a real answer that
+ * outruns them only leaves time unused. A measured run replaces them.
+ */
+/**
+ * ASSUMED: the slowest answer rate, in output tokens a second, that a step
+ * plans for on each catalog tier. An unknown model is planned at the slowest.
+ */
+export declare const AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND: Readonly<Record<AiCatalogEntry['tier'], number>>;
+/**
+ * ASSUMED: how long a provider takes to start answering — reading a prompt
+ * whose static part is cached.
+ */
+export declare const AI_JOB_ASSUMED_FIRST_TOKEN_MS = 3000;
+/** The step's own reads and writes around its generation: the site read and the draft transaction. */
+export declare const AI_JOB_STEP_OVERHEAD_MS = 3000;
+/**
+ * How long an inline door — the console route that creates a job, and the one
+ * that resumes it — waits for the step it runs before handing the job to the
+ * beat. Inside the route's 60 s `maxDuration` with room for the ladder and the
+ * writes on either side; a step still running at the bound is aborted and
+ * re-queued, and the answer says `queued`. A step whose least time is more
+ * than this is never started there at all.
+ */
+export declare const AI_JOB_INLINE_BUDGET_MS = 25000;
+/**
+ * Wall clock one beat may spend running steps before it yields (AGL-3026).
+ *
+ * Bounded by the beat route's 300 s function ceiling, not by the beat's
+ * interval: what is left of it above this is the route's own work around the
+ * sweep — loading the plugin surfaces on a cold start, the lockdown read and
+ * the beat's mark, and the last step's record after its provider call. The
+ * slowest step is fitted to this budget (`AI_JOB_STEP_MAX_MINIMUM_MS`), never
+ * the budget to the step. The beat fires every minute whatever this is, and
+ * overlapping beats are kept apart by the lease.
+ */
+export declare const AI_JOB_SWEEP_BUDGET_MS = 280000;
+/**
+ * ASSUMED: what a sweep spends before it can start its first step — the two
+ * queue queries, on a function whose Firestore channel may still be cold.
+ */
+export declare const AI_JOB_SWEEP_QUEUE_READ_MS = 4000;
+/**
+ * The most time a step may register as its least (AGL-3036): what a beat can
+ * give the first step it starts. A step that needed more could never start,
+ * so a generation whose worst case at its routing ceiling needs more asks for
+ * less than that ceiling, as much as fits this.
+ */
+export declare const AI_JOB_STEP_MAX_MINIMUM_MS: number;
+/** The tier a model is planned at: its catalog tier, else the slowest. */
+export declare function aiJobBudgetTier(model: string): AiCatalogEntry['tier'];
+/** How long an answer of `tokens` output takes on a tier at the assumed rate. */
+export declare function aiJobAssumedAnswerMs(tokens: number, tier: AiCatalogEntry['tier']): number;
+/** The shape of one generation, as the worst case counts it. */
+export interface AiGenerationShape {
+    /** Answers one generation may make: the first, and its re-ask. */
+    attempts?: number;
+    /**
+     * Inventory-lookup rounds it may spend before it answers (AGL-3036):
+     * `AI_INVENTORY_LOOKUP_MAX_ROUNDS` unless it says otherwise. A generation
+     * that carries no site inventory is offered no lookup and passes 0.
+     */
+    lookups?: number;
+    /** Time the step spends on reads of its own, beyond `AI_JOB_STEP_OVERHEAD_MS`. */
+    ownReadsMs?: number;
+}
+export interface AiGenerationTimeInput extends AiGenerationShape {
+    /** The model the step resolved: its tier decides the assumed rate. */
+    model: string;
+}
+/**
+ * The longest one generation can take at the assumed rates: every model call
+ * it may make — its lookup rounds, its answer and its re-ask — each waiting
+ * for its first token, and the allowance they share answered in full.
+ */
+export declare function aiGenerationWorstCaseMs(input: AiGenerationTimeInput & {
+    maxTokens: number;
+}): number;
+/**
+ * The same worst case for any model of a tier: what a step registers as its
+ * least time from the tier its step kind is served from, before a job has
+ * resolved a model.
+ */
+export declare function aiGenerationWorstCaseOnTierMs(input: AiGenerationShape & {
+    tier: AiCatalogEntry['tier'];
+    maxTokens: number;
+}): number;
+/**
+ * The largest answer ceiling whose worst case fits `budgetMs` on this model,
+ * and never more than `cap`. Zero when not even an empty answer fits.
+ */
+export declare function aiGenerationMaxTokensWithin(input: AiGenerationTimeInput & {
+    budgetMs: number;
+    cap: number;
+}): number;
+/** A generation step's time budget: the least time it registers, and the ceiling it asks on each model. */
+export interface AiJobStepBudget {
+    /**
+     * The step's worst case on the tier its step kind is served from, at the
+     * largest ceiling that tier may ask — never more than
+     * `AI_JOB_STEP_MAX_MINIMUM_MS`.
+     */
+    minimumMs: number;
+    /** The ceiling one answer asks on this model: the most whose worst case fits `minimumMs`. */
+    maxTokens(model: string): number;
+}
+/**
+ * The budget of a step that generates once a run (AGL-3035, AGL-3036), from
+ * the routing table's ceiling on the tier the step kind is served from.
+ *
+ * Where that worst case fits what a beat can give a step, it is the minimum,
+ * and the served tier asks the whole ceiling. Where it does not, the served
+ * tier asks the largest ceiling that fits, and the minimum is that ceiling's
+ * worst case. A slower tier asks less, so its worst case fits the same
+ * minimum; a faster one asks up to `cap` — the ceiling unless the step names a
+ * higher one — that the minimum still holds.
+ */
+export declare function aiJobStepBudget(input: AiGenerationShape & {
+    tier: AiCatalogEntry['tier'];
+    maxTokens: number;
+    cap?: number;
+}): AiJobStepBudget;

package/src/lib/jobs/ai-job-budget.js

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { aiCatalogEntry } from "../providers/catalog.js";
+import { AI_GENERATION_MAX_ATTEMPTS } from "../runtime/ai-generation-bounds.js";
+import { AI_INVENTORY_LOOKUP_MAX_ROUNDS } from "../tools/ai-inventory-lookup-tool.js";
+/**
+ * How long a generation takes, planned from what one answer costs in time
+ * (AGL-2907), so a step that generates can say how much time it needs before
+ * it starts.
+ *
+ * The job machine gives a step what is left of its caller's budget as an
+ * abort signal: the beat's sweep, or an inline door. A provider call that
+ * signal cuts off is still generated and billed upstream, while the meter
+ * records nothing. So a generation step registers the least time it needs
+ * (`registerAiJobStep(kind, runner, { minimumMs })`), and sizes its answer so
+ * its worst case — every model call it may make answered at its ceiling —
+ * fits inside that.
+ *
+ * ── Every model call, not only the answers (AGL-3036) ────────────────────
+ *
+ * A generation offered the site inventory may spend up to
+ * `AI_INVENTORY_LOOKUP_MAX_ROUNDS` model calls looking records up before it
+ * answers, each asked at the answer's ceiling. The doctrine's loop holds the
+ * whole generation — lookups, answer and re-ask — to one allowance of output,
+ * `AI_GENERATION_MAX_ATTEMPTS` times the ceiling, and asks each call for no
+ * more than is left of it. So the worst case is every call's wait for a first
+ * token, plus that allowance at the assumed rate, plus the step's own reads
+ * and writes: a lookup round adds a wait, and the output it spends is output
+ * no answer can.
+ *
+ * ── Declared assumptions, not measurements ───────────────────────────────
+ *
+ * No spec can time a provider, and no recorded run has measured one, so the
+ * two rates below are assumptions the budget is planned against, named as
+ * such here and in `docs/AI_JOBS.md`. They err slow: a real answer that
+ * outruns them only leaves time unused. A measured run replaces them.
+ */ /**
+ * ASSUMED: the slowest answer rate, in output tokens a second, that a step
+ * plans for on each catalog tier. An unknown model is planned at the slowest.
+ */ export const AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND = {
+    fast: 100,
+    balanced: 60,
+    deep: 40
+};
+/**
+ * ASSUMED: how long a provider takes to start answering — reading a prompt
+ * whose static part is cached.
+ */ export const AI_JOB_ASSUMED_FIRST_TOKEN_MS = 3000;
+/** The step's own reads and writes around its generation: the site read and the draft transaction. */ export const AI_JOB_STEP_OVERHEAD_MS = 3000;
+/**
+ * How long an inline door — the console route that creates a job, and the one
+ * that resumes it — waits for the step it runs before handing the job to the
+ * beat. Inside the route's 60 s `maxDuration` with room for the ladder and the
+ * writes on either side; a step still running at the bound is aborted and
+ * re-queued, and the answer says `queued`. A step whose least time is more
+ * than this is never started there at all.
+ */ export const AI_JOB_INLINE_BUDGET_MS = 25000;
+/**
+ * Wall clock one beat may spend running steps before it yields (AGL-3026).
+ *
+ * Bounded by the beat route's 300 s function ceiling, not by the beat's
+ * interval: what is left of it above this is the route's own work around the
+ * sweep — loading the plugin surfaces on a cold start, the lockdown read and
+ * the beat's mark, and the last step's record after its provider call. The
+ * slowest step is fitted to this budget (`AI_JOB_STEP_MAX_MINIMUM_MS`), never
+ * the budget to the step. The beat fires every minute whatever this is, and
+ * overlapping beats are kept apart by the lease.
+ */ export const AI_JOB_SWEEP_BUDGET_MS = 280000;
+/**
+ * ASSUMED: what a sweep spends before it can start its first step — the two
+ * queue queries, on a function whose Firestore channel may still be cold.
+ */ export const AI_JOB_SWEEP_QUEUE_READ_MS = 4000;
+/**
+ * The most time a step may register as its least (AGL-3036): what a beat can
+ * give the first step it starts. A step that needed more could never start,
+ * so a generation whose worst case at its routing ceiling needs more asks for
+ * less than that ceiling, as much as fits this.
+ */ export const AI_JOB_STEP_MAX_MINIMUM_MS = AI_JOB_SWEEP_BUDGET_MS - AI_JOB_SWEEP_QUEUE_READ_MS;
+/** The tier a model is planned at: its catalog tier, else the slowest. */ export function aiJobBudgetTier(model) {
+    var _ref;
+    var _aiCatalogEntry;
+    return (_ref = (_aiCatalogEntry = aiCatalogEntry(model)) == null ? void 0 : _aiCatalogEntry.tier) != null ? _ref : 'deep';
+}
+/** How long an answer of `tokens` output takes on a tier at the assumed rate. */ export function aiJobAssumedAnswerMs(tokens, tier) {
+    return Math.ceil(tokens * 1000 / AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND[tier]);
+}
+function shapeOf(input) {
+    var _input_attempts, _input_lookups, _input_ownReadsMs;
+    return {
+        attempts: (_input_attempts = input.attempts) != null ? _input_attempts : AI_GENERATION_MAX_ATTEMPTS,
+        lookups: (_input_lookups = input.lookups) != null ? _input_lookups : AI_INVENTORY_LOOKUP_MAX_ROUNDS,
+        ownReadsMs: (_input_ownReadsMs = input.ownReadsMs) != null ? _input_ownReadsMs : 0
+    };
+}
+/** Everything a generation's worst case holds but its output: a first-token wait a call, and the step's own time. */ function fixedMs(shape) {
+    return (shape.attempts + shape.lookups) * AI_JOB_ASSUMED_FIRST_TOKEN_MS + AI_JOB_STEP_OVERHEAD_MS + shape.ownReadsMs;
+}
+function worstCaseMs(shape, tier, maxTokens) {
+    return fixedMs(shape) + shape.attempts * aiJobAssumedAnswerMs(maxTokens, tier);
+}
+function maxTokensWithin(shape, tier, budgetMs, cap) {
+    const perAnswerMs = Math.floor((budgetMs - fixedMs(shape)) / shape.attempts);
+    if (perAnswerMs <= 0) return 0;
+    return Math.min(cap, Math.floor(perAnswerMs * AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND[tier] / 1000));
+}
+/**
+ * The longest one generation can take at the assumed rates: every model call
+ * it may make — its lookup rounds, its answer and its re-ask — each waiting
+ * for its first token, and the allowance they share answered in full.
+ */ export function aiGenerationWorstCaseMs(input) {
+    return worstCaseMs(shapeOf(input), aiJobBudgetTier(input.model), input.maxTokens);
+}
+/**
+ * The same worst case for any model of a tier: what a step registers as its
+ * least time from the tier its step kind is served from, before a job has
+ * resolved a model.
+ */ export function aiGenerationWorstCaseOnTierMs(input) {
+    return worstCaseMs(shapeOf(input), input.tier, input.maxTokens);
+}
+/**
+ * The largest answer ceiling whose worst case fits `budgetMs` on this model,
+ * and never more than `cap`. Zero when not even an empty answer fits.
+ */ export function aiGenerationMaxTokensWithin(input) {
+    return maxTokensWithin(shapeOf(input), aiJobBudgetTier(input.model), input.budgetMs, input.cap);
+}
+/**
+ * The budget of a step that generates once a run (AGL-3035, AGL-3036), from
+ * the routing table's ceiling on the tier the step kind is served from.
+ *
+ * Where that worst case fits what a beat can give a step, it is the minimum,
+ * and the served tier asks the whole ceiling. Where it does not, the served
+ * tier asks the largest ceiling that fits, and the minimum is that ceiling's
+ * worst case. A slower tier asks less, so its worst case fits the same
+ * minimum; a faster one asks up to `cap` — the ceiling unless the step names a
+ * higher one — that the minimum still holds.
+ */ export function aiJobStepBudget(input) {
+    var _input_cap;
+    const shape = shapeOf(input);
+    const cap = Math.max(input.maxTokens, (_input_cap = input.cap) != null ? _input_cap : input.maxTokens);
+    const served = Math.min(input.maxTokens, maxTokensWithin(shape, input.tier, AI_JOB_STEP_MAX_MINIMUM_MS, input.maxTokens));
+    const minimumMs = worstCaseMs(shape, input.tier, served);
+    return {
+        minimumMs,
+        maxTokens: (model)=>maxTokensWithin(shape, aiJobBudgetTier(model), minimumMs, cap)
+    };
+}
+
+//# sourceMappingURL=ai-job-budget.js.map

package/src/lib/jobs/ai-job-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/jobs/ai-job-budget.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { aiCatalogEntry, type AiCatalogEntry } from '../providers/catalog'\nimport { AI_GENERATION_MAX_ATTEMPTS } from '../runtime/ai-generation-bounds'\nimport { AI_INVENTORY_LOOKUP_MAX_ROUNDS } from '../tools/ai-inventory-lookup-tool'\n\n/**\n * How long a generation takes, planned from what one answer costs in time\n * (AGL-2907), so a step that generates can say how much time it needs before\n * it starts.\n *\n * The job machine gives a step what is left of its caller's budget as an\n * abort signal: the beat's sweep, or an inline door. A provider call that\n * signal cuts off is still generated and billed upstream, while the meter\n * records nothing. So a generation step registers the least time it needs\n * (`registerAiJobStep(kind, runner, { minimumMs })`), and sizes its answer so\n * its worst case — every model call it may make answered at its ceiling —\n * fits inside that.\n *\n * ── Every model call, not only the answers (AGL-3036) ────────────────────\n *\n * A generation offered the site inventory may spend up to\n * `AI_INVENTORY_LOOKUP_MAX_ROUNDS` model calls looking records up before it\n * answers, each asked at the answer's ceiling. The doctrine's loop holds the\n * whole generation — lookups, answer and re-ask — to one allowance of output,\n * `AI_GENERATION_MAX_ATTEMPTS` times the ceiling, and asks each call for no\n * more than is left of it. So the worst case is every call's wait for a first\n * token, plus that allowance at the assumed rate, plus the step's own reads\n * and writes: a lookup round adds a wait, and the output it spends is output\n * no answer can.\n *\n * ── Declared assumptions, not measurements ───────────────────────────────\n *\n * No spec can time a provider, and no recorded run has measured one, so the\n * two rates below are assumptions the budget is planned against, named as\n * such here and in `docs/AI_JOBS.md`. They err slow: a real answer that\n * outruns them only leaves time unused. A measured run replaces them.\n */\n\n/**\n * ASSUMED: the slowest answer rate, in output tokens a second, that a step\n * plans for on each catalog tier. An unknown model is planned at the slowest.\n */\nexport const AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND: Readonly<\n  Record<AiCatalogEntry['tier'], number>\n> = {\n  fast: 100,\n  balanced: 60,\n  deep: 40,\n}\n\n/**\n * ASSUMED: how long a provider takes to start answering — reading a prompt\n * whose static part is cached.\n */\nexport const AI_JOB_ASSUMED_FIRST_TOKEN_MS = 3_000\n\n/** The step's own reads and writes around its generation: the site read and the draft transaction. */\nexport const AI_JOB_STEP_OVERHEAD_MS = 3_000\n\n/**\n * How long an inline door — the console route that creates a job, and the one\n * that resumes it — waits for the step it runs before handing the job to the\n * beat. Inside the route's 60 s `maxDuration` with room for the ladder and the\n * writes on either side; a step still running at the bound is aborted and\n * re-queued, and the answer says `queued`. A step whose least time is more\n * than this is never started there at all.\n */\nexport const AI_JOB_INLINE_BUDGET_MS = 25_000\n\n/**\n * Wall clock one beat may spend running steps before it yields (AGL-3026).\n *\n * Bounded by the beat route's 300 s function ceiling, not by the beat's\n * interval: what is left of it above this is the route's own work around the\n * sweep — loading the plugin surfaces on a cold start, the lockdown read and\n * the beat's mark, and the last step's record after its provider call. The\n * slowest step is fitted to this budget (`AI_JOB_STEP_MAX_MINIMUM_MS`), never\n * the budget to the step. The beat fires every minute whatever this is, and\n * overlapping beats are kept apart by the lease.\n */\nexport const AI_JOB_SWEEP_BUDGET_MS = 280_000\n\n/**\n * ASSUMED: what a sweep spends before it can start its first step — the two\n * queue queries, on a function whose Firestore channel may still be cold.\n */\nexport const AI_JOB_SWEEP_QUEUE_READ_MS = 4_000\n\n/**\n * The most time a step may register as its least (AGL-3036): what a beat can\n * give the first step it starts. A step that needed more could never start,\n * so a generation whose worst case at its routing ceiling needs more asks for\n * less than that ceiling, as much as fits this.\n */\nexport const AI_JOB_STEP_MAX_MINIMUM_MS = AI_JOB_SWEEP_BUDGET_MS - AI_JOB_SWEEP_QUEUE_READ_MS\n\n/** The tier a model is planned at: its catalog tier, else the slowest. */\nexport function aiJobBudgetTier(model: string): AiCatalogEntry['tier'] {\n  return aiCatalogEntry(model)?.tier ?? 'deep'\n}\n\n/** How long an answer of `tokens` output takes on a tier at the assumed rate. */\nexport function aiJobAssumedAnswerMs(tokens: number, tier: AiCatalogEntry['tier']): number {\n  return Math.ceil((tokens * 1_000) / AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND[tier])\n}\n\n/** The shape of one generation, as the worst case counts it. */\nexport interface AiGenerationShape {\n  /** Answers one generation may make: the first, and its re-ask. */\n  attempts?: number\n  /**\n   * Inventory-lookup rounds it may spend before it answers (AGL-3036):\n   * `AI_INVENTORY_LOOKUP_MAX_ROUNDS` unless it says otherwise. A generation\n   * that carries no site inventory is offered no lookup and passes 0.\n   */\n  lookups?: number\n  /** Time the step spends on reads of its own, beyond `AI_JOB_STEP_OVERHEAD_MS`. */\n  ownReadsMs?: number\n}\n\nexport interface AiGenerationTimeInput extends AiGenerationShape {\n  /** The model the step resolved: its tier decides the assumed rate. */\n  model: string\n}\n\ninterface Shape {\n  attempts: number\n  lookups: number\n  ownReadsMs: number\n}\n\nfunction shapeOf(input: AiGenerationShape): Shape {\n  return {\n    attempts: input.attempts ?? AI_GENERATION_MAX_ATTEMPTS,\n    lookups: input.lookups ?? AI_INVENTORY_LOOKUP_MAX_ROUNDS,\n    ownReadsMs: input.ownReadsMs ?? 0,\n  }\n}\n\n/** Everything a generation's worst case holds but its output: a first-token wait a call, and the step's own time. */\nfunction fixedMs(shape: Shape): number {\n  return (\n    (shape.attempts + shape.lookups) * AI_JOB_ASSUMED_FIRST_TOKEN_MS +\n    AI_JOB_STEP_OVERHEAD_MS +\n    shape.ownReadsMs\n  )\n}\n\nfunction worstCaseMs(shape: Shape, tier: AiCatalogEntry['tier'], maxTokens: number): number {\n  return fixedMs(shape) + shape.attempts * aiJobAssumedAnswerMs(maxTokens, tier)\n}\n\nfunction maxTokensWithin(shape: Shape, tier: AiCatalogEntry['tier'], budgetMs: number, cap: number): number {\n  const perAnswerMs = Math.floor((budgetMs - fixedMs(shape)) / shape.attempts)\n  if (perAnswerMs <= 0) return 0\n  return Math.min(cap, Math.floor((perAnswerMs * AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND[tier]) / 1_000))\n}\n\n/**\n * The longest one generation can take at the assumed rates: every model call\n * it may make — its lookup rounds, its answer and its re-ask — each waiting\n * for its first token, and the allowance they share answered in full.\n */\nexport function aiGenerationWorstCaseMs(input: AiGenerationTimeInput & { maxTokens: number }): number {\n  return worstCaseMs(shapeOf(input), aiJobBudgetTier(input.model), input.maxTokens)\n}\n\n/**\n * The same worst case for any model of a tier: what a step registers as its\n * least time from the tier its step kind is served from, before a job has\n * resolved a model.\n */\nexport function aiGenerationWorstCaseOnTierMs(\n  input: AiGenerationShape & { tier: AiCatalogEntry['tier']; maxTokens: number },\n): number {\n  return worstCaseMs(shapeOf(input), input.tier, input.maxTokens)\n}\n\n/**\n * The largest answer ceiling whose worst case fits `budgetMs` on this model,\n * and never more than `cap`. Zero when not even an empty answer fits.\n */\nexport function aiGenerationMaxTokensWithin(\n  input: AiGenerationTimeInput & { budgetMs: number; cap: number },\n): number {\n  return maxTokensWithin(shapeOf(input), aiJobBudgetTier(input.model), input.budgetMs, input.cap)\n}\n\n/** A generation step's time budget: the least time it registers, and the ceiling it asks on each model. */\nexport interface AiJobStepBudget {\n  /**\n   * The step's worst case on the tier its step kind is served from, at the\n   * largest ceiling that tier may ask — never more than\n   * `AI_JOB_STEP_MAX_MINIMUM_MS`.\n   */\n  minimumMs: number\n  /** The ceiling one answer asks on this model: the most whose worst case fits `minimumMs`. */\n  maxTokens(model: string): number\n}\n\n/**\n * The budget of a step that generates once a run (AGL-3035, AGL-3036), from\n * the routing table's ceiling on the tier the step kind is served from.\n *\n * Where that worst case fits what a beat can give a step, it is the minimum,\n * and the served tier asks the whole ceiling. Where it does not, the served\n * tier asks the largest ceiling that fits, and the minimum is that ceiling's\n * worst case. A slower tier asks less, so its worst case fits the same\n * minimum; a faster one asks up to `cap` — the ceiling unless the step names a\n * higher one — that the minimum still holds.\n */\nexport function aiJobStepBudget(\n  input: AiGenerationShape & { tier: AiCatalogEntry['tier']; maxTokens: number; cap?: number },\n): AiJobStepBudget {\n  const shape = shapeOf(input)\n  const cap = Math.max(input.maxTokens, input.cap ?? input.maxTokens)\n  const served = Math.min(\n    input.maxTokens,\n    maxTokensWithin(shape, input.tier, AI_JOB_STEP_MAX_MINIMUM_MS, input.maxTokens),\n  )\n  const minimumMs = worstCaseMs(shape, input.tier, served)\n  return {\n    minimumMs,\n    maxTokens: (model) => maxTokensWithin(shape, aiJobBudgetTier(model), minimumMs, cap),\n  }\n}\n"],"names":["aiCatalogEntry","AI_GENERATION_MAX_ATTEMPTS","AI_INVENTORY_LOOKUP_MAX_ROUNDS","AI_JOB_ASSUMED_OUTPUT_TOKENS_PER_SECOND","fast","balanced","deep","AI_JOB_ASSUMED_FIRST_TOKEN_MS","AI_JOB_STEP_OVERHEAD_MS","AI_JOB_INLINE_BUDGET_MS","AI_JOB_SWEEP_BUDGET_MS","AI_JOB_SWEEP_QUEUE_READ_MS","AI_JOB_STEP_MAX_MINIMUM_MS","aiJobBudgetTier","model","tier","aiJobAssumedAnswerMs","tokens","Math","ceil","shapeOf","input","attempts","lookups","ownReadsMs","fixedMs","shape","worstCaseMs","maxTokens","maxTokensWithin","budgetMs","cap","perAnswerMs","floor","min","aiGenerationWorstCaseMs","aiGenerationWorstCaseOnTierMs","aiGenerationMaxTokensWithin","aiJobStepBudget","max","served","minimumMs"],"mappings":"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"}

package/src/lib/jobs/ai-job-campaign-step.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { PluginDraftRecord } from '@aglyn/aglyn/plugin-manager/plugin-resource-drafts';
+import type { AiJob, AiJobOutput } from '../model/ai-jobs.types';
+import { readSiteInventory } from '../runtime/site-inventory';
+import { type AiJobAdmission } from './ai-job-admission';
+import { type AiEmailCopy } from './ai-job-email-step';
+import { type AiPluginDraftWriterLookup } from './ai-job-plugin-drafts';
+import type { AiJobStepRunner } from './ai-job-text-step';
+/**
+ * The campaign step (AGL-2912): one brief becomes an email design AND the
+ * draft campaign that would send it.
+ *
+ * A campaign is an unplanned kind — there is one thing to build and a plan
+ * over it would be a plan of one — so the job runs this step alone, and the
+ * design it writes is the email step's, generated through `generateAiEmail`
+ * so both kinds obey the same doctrine and the same email rules.
+ *
+ * ## Nothing is sent, and nothing is aimed
+ *
+ * The campaign is written `draft`, with no audience, no schedule and no
+ * sender: a draft campaign is not a queued one, the scheduled processor
+ * queries `status == 'scheduled'`, and the send route is the only thing that
+ * mails a campaign. Choosing WHO receives it stays a person's decision, so
+ * the model is never shown the org's lists, its contacts or what past sends
+ * did. Code reads the list the brief names and the send time that list's own
+ * history suggests, AFTER the answer, and both reach the person as the
+ * output's `note` — never the prompt.
+ *
+ * ## Where campaign email begins
+ *
+ * A site whose plan sends no campaign email can still generate email designs;
+ * the campaign is the part that needs somewhere to send. So the step gates on
+ * the same entitlement the composer and the send route read, and stops the
+ * job for a person rather than failing it. The refusal names no plan, because
+ * the billing page is the one place that does.
+ *
+ * ## Run again and it finds its drafts
+ *
+ * Each write is keyed by the id the job recorded for its draft when it was
+ * created, so a run cut off between them finds what it wrote: two drafts are
+ * reported, a design alone is drafted into a campaign from the copy the
+ * design already stores, and neither spends.
+ */
+/** The id the marketing plugin is registered under. */
+export declare const AI_CAMPAIGN_PLUGIN_ID = "marketing";
+/** The resource the marketing plugin writes a draft campaign under. */
+export declare const AI_CAMPAIGN_RESOURCE = "campaign";
+/** A campaign's name when neither the job nor its subject lines give one. */
+export declare const AI_JOB_CAMPAIGN_DEFAULT_NAME = "New campaign";
+/** A job's failure when the site has no campaign writer. */
+export declare const AI_CAMPAIGN_UNAVAILABLE_COPY = "Campaigns are not available on this site.";
+/** A job's failure when a campaign whose email was written could not be drafted. */
+export declare const AI_CAMPAIGN_SAVE_FAILURE_COPY = "The email was written but the campaign could not be drafted. Try the job again.";
+/**
+ * What a person is told when their plan sends no campaign email. It names the
+ * page that sells the answer rather than a plan, so the one place plan names
+ * are written stays the one place they are read.
+ */
+export declare const AI_CAMPAIGN_PLAN_REFUSAL: string;
+/** Whether this workspace may send campaign email at all: the composer's and the send route's check. */
+export declare function aiCampaignPlanAllows(org: object | null): boolean;
+/** The campaign as the job's output, carrying what the person still decides. */
+export declare function aiCampaignOutput(record: PluginDraftRecord, place: {
+    hostId: string;
+    hostSubdomain: string | null;
+}, note: string | null): AiJobOutput;
+/** The subject lines and preheaders a written design already stores. */
+export declare function aiCampaignCopyFromDesign(record: PluginDraftRecord): AiEmailCopy;
+/** The campaign's content: the design it sends, and the copy the send fills its headers from. */
+export declare function aiCampaignDraftContent(designId: string, copy: AiEmailCopy): Record<string, unknown>;
+/** A campaign job's name: what the member asked for, else its strongest subject line. */
+export declare function aiCampaignName(job: Pick<AiJob, 'inputs'>, copy: AiEmailCopy): string;
+/**
+ * A campaign job is admitted for a site of its org with email and marketing
+ * on, room for a design and a campaign, and a plan that sends campaign email.
+ */
+export declare const aiCampaignJobAdmission: AiJobAdmission;
+export interface AiJobCampaignStepDeps {
+    /** The inventory reader; specs hand in a fake. */
+    readInventory?: typeof readSiteInventory;
+    /** How a resource's draft writer is found; the core's registry otherwise. */
+    writerFor?: AiPluginDraftWriterLookup;
+}
+export declare function createAiJobCampaignStep(deps?: AiJobCampaignStepDeps): AiJobStepRunner;
+export declare const runAiJobCampaignStep: AiJobStepRunner;
+/**
+ * The least time one campaign step needs before it starts (AGL-3035): the
+ * email generation it drafts the campaign's design with, on the campaign's own
+ * routing row. Writing the draft campaign asks no model.
+ */
+export declare const AI_JOB_CAMPAIGN_STEP_MINIMUM_MS: number;
+/** Registers the campaign step and the check a campaign job passes before it is created or resumed. */
+export declare function registerAiCampaignJob(): void;