audit-tools 0.39.15 → 0.41.0

package/dist/shared/quota/apiPool.d.ts

@@ -1,322 +0,0 @@
-import type { CapacityPool } from "./capacity.js";
-import { type DispatchableSource, type ResolvedProviderName, type SessionConfig } from "../types/sessionConfig.js";
-import type { DroppedSource } from "../providers/auditorSources.js";
-import type { DispatchModelTier } from "../types/stepContract.js";
-import type { HostConcurrencyLimit, QuotaStateEntry } from "./types.js";
-import type { QuotaSource } from "./quotaSource.js";
-import type { DiscoveredRateLimitsInput, HostModelRosterEntry } from "./scheduler.js";
-import type { DispatchExclusion } from "../providers/dispatchExclusion.js";
-/**
- * The stable id of a dispatchable source — its explicit `id`, or the quota-ledger
- * pool identity `service[#account]/(model ?? endpoint ?? *)` ({@link quotaPoolKey})
- * so two sources onto the same service stay distinct as long as their model/endpoint
- * differ. This is the CapacityPool id and the key learned quota is recorded under.
- * (It said `transport[...]` until stage 1 normalized `service` at the chokepoint; the
- * transport arm below is now the unreachable fallback, not the main path.)
- *
- * The account component is load-bearing here: it prevents independent credentials
- * from collapsing into one quota pool while still deduplicating two transports that
- * reach the same service, account, and model.
- */
-export declare function dispatchableSourceId(source: DispatchableSource, account?: string | null): string;
-/**
- * The effective per-request context window (tokens) for a dispatchable source — a
- * positive integer when declared/discovered, otherwise null. Fit gates treat null
- * as unadmittable: the earlier "unknown ⇒ always fits" behavior silently no-op'd
- * every fit gate for a proxy pool whose registry entry carried no context field.
- * Resolution chain:
- *   1. operator/registry-declared `quota.context_tokens` (the stamp populate sets),
- *   2. else the BACKEND model's models.dev window (`resolveModelStatics(model,
- *      service ?? transport)` — a synced, someone-else-maintained table),
- *   3. else unknown (`null`) — never a guessed window.
- * Single-sourced (exported) as the one fit-window resolver. Only `buildSourcePool`
- * stamps it — host-model pools carry no `contextCapTokens` and gate (on the admission
- * path) against their own per-pool `resolved_limits` window instead; the admission
- * builder folds the two (`context_cap_tokens ?? resolved_limits.context_tokens`) so
- * BOTH pool classes share one fit predicate (unified-routing step B).
- */
-export declare function resolveSourceContextWindowTokens(source: DispatchableSource): number | null;
-/**
- * Bridge a generic {@link DispatchableSource} to the concrete per-provider config
- * block its provider constructor expects, so `createFreshSessionProvider` can build
- * the right backend FROM the source (not the global block). `endpoint` + `parameters`
- * are interpreted per provider: the API base_url + sampling params for
- * `openai-compatible`; the launcher command + CLI args for the headless CLIs.
- */
-export declare function sourceProviderConfig(source: DispatchableSource): Partial<SessionConfig>;
-/**
- * Overlay a dispatchable source's per-provider config block onto the session config,
- * so `createFreshSessionProvider` builds the backend FROM that source — the launch
- * reads THIS source's `{endpoint, model, parameters}`, not the global block. This is
- * what lets two sources of the same transport (e.g. two NIM endpoints) launch
- * distinctly. A node on the host's own pool (no source) passes the config through.
- */
-export declare function withSourceConfig(sessionConfig: SessionConfig, source: DispatchableSource | undefined): SessionConfig;
-/**
- * Assemble ONE host-model CapacityPool from already-resolved inputs — the shared
- * pool-shape + quota-probe core both orchestrators' host-pool builders use, so the
- * CapacityPool shape can't drift between them. The per-tool parts (the pool key and
- * the discovered-limits computation) are resolved by the caller and passed in.
- *
- * `hostModel` is DERIVED from `poolKey` (never accepted as a separate scalar) so the
- * pool is correct-by-construction: `pool.hostModel === parseProviderModelKey(pool.id).model`
- * always holds. A roster builds one pool per rank with a distinct per-rank model in
- * the key; passing a single scalar host model alongside would mis-stamp every
- * non-primary pool, which is the leak this seam closes. See {@link buildHostModelPools}.
- */
-export declare function buildHostModelPool(params: {
-    poolKey: string;
-    providerName: ResolvedProviderName;
-    rank?: DispatchModelTier;
-    hostConcurrencyLimit: HostConcurrencyLimit | null;
-    quotaStateEntry: QuotaStateEntry | null;
-    discoveredLimits: DiscoveredRateLimitsInput | null;
-    quotaSource: QuotaSource;
-    /**
-     * Confirmed per-model capability ranks (see {@link resolveDeclaredCapabilityRank}).
-     * The host's models are ranked exactly like every other model — a host pool is not
-     * capability-evidence-free by nature, it was simply never looked up (before this,
-     * `declaredCapabilityRank` had a single writer on the SOURCE path, so every host pool
-     * banded to `null` and took the floor's fail-open branch on every ordinary wave).
-     *
-     * Required (never optional): the floor fails OPEN, so an unwired call site would be
-     * indistinguishable from a working one. `null` is the explicit "no confirmation in
-     * scope" answer.
-     */
-    capabilityRanks: ReadonlyMap<string, number> | null;
-}): Promise<CapacityPool>;
-/**
- * Build a host-model CapacityPool per roster rank (or one pool for the scalar/absent
- * handshake) — the shared host-pool-from-roster core both orchestrators drive. The
- * caller's `resolve(entry)` supplies the only per-tool parts: the pool key and the
- * discovered-limits (audit merges capability + provider + cached limits; remediate
- * uses the roster/capability pair). Everything else — the roster iteration, the
- * learned-quota lookup, and the pool assembly — is shared. Audit layers its
- * contextBudget / tierBudget computation on top of the returned pools.
- */
-export declare function buildHostModelPools(params: {
-    providerName: ResolvedProviderName;
-    hostModel: string | null;
-    hostConcurrencyLimit: HostConcurrencyLimit | null;
-    quotaSource: QuotaSource;
-    quotaEntries: Record<string, QuotaStateEntry>;
-    roster: HostModelRosterEntry[] | null;
-    /** Confirmed per-model capability ranks — see {@link resolveDeclaredCapabilityRank}. Required (never optional): the floor fails OPEN, so an unwired call site would be indistinguishable from a working one. `null` is the explicit "no confirmation in scope" answer. */
-    capabilityRanks: ReadonlyMap<string, number> | null;
-    resolve: (entry: HostModelRosterEntry | null) => Promise<{
-        poolKey: string;
-        discoveredLimits: DiscoveredRateLimitsInput | null;
-    }> | {
-        poolKey: string;
-        discoveredLimits: DiscoveredRateLimitsInput | null;
-    };
-}): Promise<CapacityPool[]>;
-/** Index the source-backed pools by their pool id, for per-node provider resolution. */
-export declare function sourceByPoolId(pools: Array<{
-    id: string;
-    source?: DispatchableSource;
-}>): Map<string, DispatchableSource>;
-/**
- * Build one CapacityPool for a configured dispatchable backend source — generic over
- * the source's transport. An independent backend pool: it does not draw on the host
- * subagent budget (`hostConcurrencyLimit: null`); its rate limits come from the
- * source's own `quota` (RPM/TPM/context/output) plus learned 429 state; it carries
- * its real-time quota probe (degraded → the raw `quotaSignalDegraded` marker). The
- * pool is TAGGED with its `source` so the dispatch worker rebuilds the provider from
- * the source's `{endpoint, model, parameters}`, not the global per-provider block.
- */
-export declare function buildSourcePool(params: {
-    source: DispatchableSource;
-    quotaSource: QuotaSource;
-    quotaEntries: Record<string, QuotaStateEntry>;
-    /** Confirmed per-model capability ranks — see {@link resolveDeclaredCapabilityRank}. Required (never optional): the floor fails OPEN, so an unwired call site would be indistinguishable from a working one. `null` is the explicit "no confirmation in scope" answer. */
-    capabilityRanks: ReadonlyMap<string, number> | null;
-}): Promise<CapacityPool>;
-/**
- * The DispatchableSource for the primary in-process backend, built from its own config
- * block, so the primary is just a SOURCE POOL in the one eligible pool set (H2+H4
- * collapse): an attended host fans out onto it alongside its own subagents, and a
- * headless run's engine drives it as an ordinary member pool — there is no demote
- * flag and no monopoly branch. Returns null when the primary provider is not a
- * self-drivable in-process backend under the DRAW's policy (`commandWorkers` —
- * remediate admits the command-shaped backends, audit does not), or its config block
- * is absent where one is required. The dispatch worker rebuilds the concrete provider
- * from this source's `{endpoint, model, parameters}` via `withSourceConfig`.
- */
-export declare function primaryInProcessSource(sessionConfig: SessionConfig, primaryProviderName: string, options?: {
-    commandWorkers?: boolean;
-}): DispatchableSource | null;
-/**
- * The gather's full answer: the lanes that route, AND the lanes that did not, each
- * with an operator-facing reason.
- *
- * Deliberately the SAME shape as `resolveAmbientSources`' `ResolvedSourceSet`
- * (`auditorSources.ts`) and reusing its `DroppedSource`, because the two apply the
- * same `laneWorkerKindConflict` predicate at two genuinely distinct chokepoints —
- * ambient resolution, and this one, which descriptor-supplied `sources[]` reach
- * WITHOUT passing ambient resolution. One shape, so a consumer handles a drop
- * identically wherever it came from.
- */
-export interface DispatchableSourceSet {
-    sources: DispatchableSource[];
-    /** Empty when nothing was dropped — never absent, so an unwired call site cannot masquerade as a clean gather. */
-    dropped: DroppedSource[];
-}
-/**
- * Every dispatchable backend source configured for a run, in pool order: the explicit
- * `sessionConfig.sources`, the primary in-process backend folded in UNCONDITIONALLY
- * (H2+H4 collapse: the primary is just a source pool — there is no demote flag; which
- * providers fold is the draw's `commandWorkers` policy), plus — for back-compat — a
- * single implicit source folded in from a legacy `openai_compatible` block when it
- * isn't the primary provider and isn't already covered by an explicit source of the
- * same id.
- *
- * Returns the PAIR `{ sources, dropped }`, mirroring `resolveAmbientSources`
- * (`auditorSources.ts`), which applies the same `laneWorkerKindConflict` predicate.
- * A routing-filtered lane must be a value the caller can read, not only a stderr
- * line: source discovery can feed read-only diagnostics, where a dropped
- * backend stays VISIBLE and marked so the operator can act on it — the same reason
- * `excludedBackends` is filtered on the routing side rather than in the gather.
- * A stderr-only report also self-suppresses after the first (lane, reason) in a
- * process, so a second gather said nothing at all.
- */
-export declare function collectDispatchableSources(sessionConfig: SessionConfig, primaryProviderName: string, options?: {
-    commandWorkers?: boolean;
-}): DispatchableSourceSet;
-/**
- * The FULL dispatchable source list for a run — the configured
- * `collectDispatchableSources` set. The single async source-gather point: both the
- * dispatch pool builder ({@link buildSourcePools}) and source diagnostics
- * consume it, so what the operator confirms is exactly what routes (no display/dispatch
- * drift on the source set). Async is retained as the stable seam for the per-auditor
- * inventory resolution the handshake will feed here.
- */
-export declare function gatherDispatchableSources(sessionConfig: SessionConfig, primaryProviderName: string, options?: {
-    commandWorkers?: boolean;
-}): Promise<DispatchableSourceSet>;
-/**
- * A self-spawn-zeroed dispatch capacity: reach existed and the local safety guard
- * removed all of it. Distinct from a legitimately empty build (nothing configured),
- * which is normal operation and carries no fact.
- */
-export interface ExclusionZeroing {
-    /** How many sources were gathered before the rules were applied. */
-    gatheredCount: number;
-    /** The mechanical transport patterns that did it, deduplicated and sorted. */
-    patterns: string[];
-}
-/**
- * The result of a source-pool build.
- *
- * A RETURN VALUE rather than an optional `onZeroed` hook — deliberately, and unlike
- * the reactive `onCostDrift` / `onCreditExhausted` / `onModelUnavailable` hooks the
- * rolling engine uses. Those may be omitted to leave an event silent; here silence IS
- * the defect being fixed, so the fact must be impossible to drop by forgetting. A
- * required field on the return type cannot be omitted, only ignored deliberately.
- */
-export interface SourcePoolBuild {
-    pools: CapacityPool[];
-    /** Non-null ONLY when exclusion rules zeroed a non-empty gathered set. */
-    zeroedByExclusion: ExclusionZeroing | null;
-    /**
-     * Lanes the worker-kind × pool-class rule filtered out, each with its reason.
-     * Empty when none — never absent, so an unwired consumer cannot look like a
-     * clean build. Distinct from `zeroedByExclusion`, which is the OPERATOR's own
-     * rules removing reach that existed; these lanes were never routable.
-     */
-    dropped: DroppedSource[];
-}
-/**
- * Build the CapacityPool for every configured dispatchable backend source (the
- * generalization of the former openai-compatible-only `buildConfiguredApiPool`): one
- * pool per source, the IDENTICAL shape across audit + remediate, so the spill topology
- * can't drift and the operator can configure ANY non-IDE source — multiple NIM/vLLM
- * endpoints, a CLI pool, … — each with its own rate limit.
- */
-export declare function buildSourcePools(params: {
-    sessionConfig: SessionConfig;
-    primaryProviderName: string;
-    quotaSource: QuotaSource;
-    quotaEntries: Record<string, QuotaStateEntry>;
-    /** The draw's fold policy: admit command-shaped primaries (remediate) or not (audit). */
-    commandWorkers?: boolean;
-    /**
-     * Backends recomputed as self-spawn-blocked in THIS process
-     * (`buildSelfSpawnExclusion`). Applied as a
-     * set-difference over freshly-gathered reach — never additively.
-     *
-     * A matcher rather than a name set because the grammar is MODEL-granular
-     * (`provider:model`): excluding one model of a multi-model backend must leave that
-     * backend's other sources routable, which a provider-name set cannot express.
-     *
-     * Filtered HERE, on the routing side, rather than inside
-     * {@link gatherDispatchableSources}: the gather may also feed read-only source
-     * display, where an excluded provider must stay VISIBLE and marked excluded so the
-     * operator can see it and opt it back in. Display and routing diverge deliberately.
-     *
-     * Omit ⇒ no filtering, so a caller that has
-     * no confirmation to read behaves exactly as before.
-     */
-    excludedBackends?: DispatchExclusion;
-    /** Confirmed per-model capability ranks — see {@link resolveDeclaredCapabilityRank}. Required (never optional): the floor fails OPEN, so an unwired call site would be indistinguishable from a working one. `null` is the explicit "no confirmation in scope" answer. */
-    capabilityRanks: ReadonlyMap<string, number> | null;
-}): Promise<SourcePoolBuild>;
-/**
- * Re-derive each pool's `quotaStateEntry` by folding in the account-scoped
- * cooldown/429 signal from its siblings (Bug 3 / Slice A3: account-axis pool
- * identity). Applied ONCE across the whole freshly-built pool set — after
- * this, every pool's frozen `quotaStateEntry` already reflects the worst
- * cooldown its account has seen, so a peer whose OWN key never recorded a 429
- * still shows up degraded. This is the construction-time counterpart to the
- * live fold `selectProvider` applies mid-run in `rollingDispatch.ts` (same
- * {@link foldAccountCooldown} primitive, single-sourced). A pool with no
- * derivable account (not `openai-compatible`, missing endpoint/api_key_env, or
- * an explicit `source.account` override) is returned unchanged.
- */
-/**
- * Cross-class host-vs-source pool dedup (H2+H4 collapse, plan D1) — the ONE shared
- * collision rule both draws apply when assembling their eligible pool set. With the
- * primary in-process backend folded in UNCONDITIONALLY, the attended host's pool
- * identity can collide with a folded source's `dispatchableSourceId` (the classic
- * case: conversation host codex + `provider: codex` — one credential, one account;
- * emitting both pools double-books that one meter and can collide on a single pool
- * id, the retired B1 same-agent guard's bug class
- * [[host-provider-misattribution-nim-codex]]).
- *
- * Collision = same provider identity on the same account axis. Provider identity is
- * the BACKEND when the source declares one (`service` — a proxied lane onto
- * the host's own backend is exactly the double-grant this guards; review h2c3 F5),
- * else the pool's providerName. The account compare is DIRECTIONAL (review h2c3 F3):
- * a source with NO declared account collides on provider alone — the synthesized
- * primary fold shares the host credential by construction — but a source with an
- * EXPLICIT account collides only when the host's account resolves equal; a host
- * whose account is merely unresolved (dark credential) must never lose its lane to
- * a source declared on a DIFFERENT account. Deliberately NOT model-granular: the
- * double-grant boundary this protects is `(provider, account)`, not the model axis.
- *
- * Survivor rule (D1): on collision the SOURCE/engine pool survives when its provider
- * is an in-process worker — the engine drives that one account and the host has no
- * separate pool to double-book (preserving self-drive for attended
- * provider=codex=host); the HOST pool survives otherwise (a host-shaped identity is
- * not an engine-drivable source).
- *
- * `hostProviderName` serves the draw whose host is NOT a member pool (audit, plan
- * D6: the host is the coverage-driven complement): with no host pools to drop, the
- * rule degenerates to dropping a colliding non-in-process source.
- */
-export declare function dedupHostAndSourcePools(params: {
-    hostPools: CapacityPool[];
-    sourcePools: CapacityPool[];
-    /** Attended host identity for a draw whose host is not a member pool (audit). */
-    hostProviderName?: ResolvedProviderName | null;
-    /**
-     * The DRAW's worker policy for the D1 survivor rule (remediate admits
-     * command-shaped workers; audit does not) — a command-shaped source can only
-     * survive a collision on a draw whose engine can actually drive it.
-     */
-    commandWorkers?: boolean;
-}): {
-    hostPools: CapacityPool[];
-    sourcePools: CapacityPool[];
-};
-//# sourceMappingURL=apiPool.d.ts.map

package/dist/shared/quota/apiPool.d.ts.map

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