@eddyskywalker/dsh-chatgpt-subscription 0.46.1 → 0.48.0

package/lib/types/host/workbuddy/account-pool.d.ts

@@ -0,0 +1,389 @@
+/**
+ * WorkBuddy's account pool.
+ *
+ * This line is the one that adopts accounts it does not own: alongside the
+ * accounts a user signs in through this plugin, it reads the CodeBuddy desktop
+ * client's own `*.info` credentials so an existing IDE sign-in needs no second
+ * login. Both kinds take part in scheduling through the shared
+ * {@link AccountPoolCore}, and the difference is enforced here:
+ *
+ * - **managed** accounts were signed in through this plugin. They live in the
+ *   pool's encrypted storage and may be deleted.
+ * - **desktop** accounts belong to the IDE. Their credential is re-read from the
+ *   IDE's file on every pick, because the IDE rotates it on its own schedule and
+ *   a cached copy would go stale; they are never deleted, only hidden.
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { AccountPoolCore, type PoolAccountShape, type PoolData } from '../common/account-pool.ts';
+import type { CredentialStore } from '../token-store.ts';
+import { FileCredentialStore, type WorkBuddyCredentials } from './token-store.ts';
+import type { PoolAccountQuotaDto } from '../../shared/account-pool-contracts.ts';
+import { type WorkBuddyAccountQuota, type WorkBuddyAccountRestrictionDto, type WorkBuddyAccountSummaryDto, type WorkBuddyPoolStateDto, type WorkBuddyRegion } from '../../shared/workbuddy-contracts.ts';
+/** One pooled WorkBuddy account: the credential plus the facts the card renders. */
+export interface WorkBuddyPoolAccount extends PoolAccountShape<WorkBuddyCredentials> {
+    region: WorkBuddyRegion;
+    nickname?: string;
+    uin?: string;
+    /** Which store owns the credential; only managed accounts may be deleted. */
+    source: 'desktop' | 'managed';
+    /** IDE file a desktop account came from; absent for managed accounts. */
+    sourceFile?: string;
+}
+/** Encrypted pool file this line owns. */
+export declare function workBuddyPoolPath(): string;
+/**
+ * Error code the adapter routes on when the WHOLE pool is paused.
+ *
+ * Deliberately not `RATE_LIMIT`: a pause says the pool will not be served at
+ * all — the upstream barred accounts, it did not answer 429 for one request —
+ * and confusing the two would send the user to wait out a window that has
+ * nothing to do with their accounts. The pause lifts by itself and the RESTRICTED
+ * accounts do not, so the remedy is also different.
+ */
+export declare const WORKBUDDY_POOL_PAUSED_CODE: "WORKBUDDY_POOL_PAUSED";
+/**
+ * Thrown instead of selecting an account while the whole pool is paused.
+ *
+ * Exported so the protocol worker's caller can tell "upstream barred two
+ * accounts" (wait for the pause, then sign the restricted ones in again) from
+ * "this request was rate limited". It is never reported as an upstream 429.
+ */
+export declare class WorkBuddyPoolPausedError extends LlmError {
+    /** Unix milliseconds the pause lifts on its own; absent when nothing named one. */
+    readonly pausedUntil: number | undefined;
+    constructor(message: string, pausedUntil?: number);
+}
+/**
+ * How long a second barred account stops the whole pool.
+ *
+ * Thirty minutes is the confirmed Wave 2A policy: long enough that an upstream
+ * refusing every account is not hammered once per turn, short enough that a
+ * transient bar does not take the line offline for a working day. When it
+ * passes the pool resumes by itself — the restricted accounts do not, because
+ * nothing upstream said they may serve again.
+ */
+export declare const WORKBUDDY_POOL_PAUSE_MS: number;
+/**
+ * Window in which a second, DIFFERENT barred account stops the whole pool.
+ *
+ * Measured from each refusal to the next. One barred account is that account's
+ * problem and the rest still serve; two different accounts barred inside this
+ * window is the pool's problem, because the same thing is about to happen to
+ * the third.
+ */
+export declare const WORKBUDDY_RESTRICTION_ESCALATION_WINDOW_MS: number;
+/** One account's `11140` as this pool's own document keeps it. */
+export interface WorkBuddyPoolRestrictionRecord {
+    /** Gateway code; {@link WORKBUDDY_RESTRICTED_ACCOUNT_CODE} is the only one recorded. */
+    code: number;
+    /** Upstream `msg` when one came with the code. Never a credential. */
+    message?: string;
+    /** Instant the gateway named, when it named one. Reported, never enforced. */
+    until?: number;
+    /** When this pool observed the refusal; drives the escalation window. */
+    observedAt: number;
+}
+/** A pause of the WHOLE pool, as its own document keeps it. */
+export interface WorkBuddyPoolPauseRecord {
+    /** Composed sentence for the card; never a token. */
+    reason: string;
+    pausedSince: number;
+    /** Unix milliseconds the pause lifts by itself. */
+    pausedUntil: number;
+    /** Account ids whose `11140` caused the pause, in observation order. */
+    triggeredBy: string[];
+}
+/** Whole-pool state kept inside the pool document. */
+export interface WorkBuddyPoolDocumentState {
+    /** Account id → its `11140`. A restricted account is out of rotation. */
+    restrictions: Record<string, WorkBuddyPoolRestrictionRecord>;
+    pause?: WorkBuddyPoolPauseRecord;
+}
+/**
+ * This line's pool document: the shared shape plus the pool-wide state.
+ *
+ * The state lives in the SAME document rather than a second store, so one
+ * encrypted write keeps "which account may serve" and "may the pool serve at
+ * all" in step: two documents could be observed half-updated, and the pool
+ * would then select an account its own restriction record bars.
+ */
+export interface WorkBuddyPoolData extends PoolData<WorkBuddyPoolAccount> {
+    pool?: WorkBuddyPoolDocumentState;
+}
+/**
+ * Read whole-pool state out of a stored document.
+ *
+ * Absent means "no pool-wide state", which is exactly what a document written
+ * before Wave 2A holds — and what an untouched pool still writes, so an install
+ * that never met `11140` carries no extra keys at all. A malformed ENTRY is
+ * dropped rather than failing the document: losing one memory of a refusal must
+ * not make the accounts unreadable, while silently keeping an unparseable pause
+ * could take the line offline forever.
+ */
+export declare function parseWorkBuddyPoolState(value: unknown): WorkBuddyPoolDocumentState | undefined;
+/**
+ * Validate and normalize one whole pool document.
+ *
+ * A record whose credential is unusable is dropped rather than repaired: the
+ * account can always be adopted again from its file or by signing in again, and
+ * keeping a credential-less row would offer the user an account nothing can use.
+ */
+export declare function parseWorkBuddyPoolData(value: unknown): WorkBuddyPoolData;
+/**
+ * One cached snapshot as the shared account card renders it.
+ *
+ * Only what the DTO states is published: every meter that measured a share
+ * becomes a window, and a meter that measured none is dropped rather than drawn
+ * at 0 — which would claim an unspent allowance no reading supports.
+ *
+ * Exported for the pool's regression tests; the card only reaches it through
+ * the summary hook.
+ */
+export declare function workBuddyPoolQuota(snapshot: WorkBuddyAccountQuota): PoolAccountQuotaDto | undefined;
+export interface WorkBuddyAccountPoolOptions {
+    /** Credential store the desktop scan reads through; the pool owns scheduling. */
+    store?: FileCredentialStore;
+    /** Test seam; production builds the platform backend from the pool path. */
+    backend?: CredentialStore<PoolData<WorkBuddyPoolAccount>>;
+    maxAccounts?: number;
+    /**
+     * The settings selection: the account the user pinned and the ones hidden.
+     *
+     * Read on every pick rather than captured once, because both change from the
+     * settings card while the adapter is serving requests.
+     */
+    selection?: () => {
+        selectedAccountId: string | null;
+        hiddenAccountIds: readonly string[];
+    };
+}
+/**
+ * WorkBuddy's account pool.
+ *
+ * Desktop accounts are adopted into the pool so they can be scheduled and
+ * cooled down like any other, but they stay owned by the IDE: the pool refreshes
+ * their credential from the IDE's own file on every pick, and deletion is
+ * refused for them.
+ */
+export declare class WorkBuddyAccountPool extends AccountPoolCore<WorkBuddyCredentials, WorkBuddyPoolAccount, WorkBuddyAccountSummaryDto> {
+    private readonly store;
+    private readonly options_selection;
+    /**
+     * Older settings key → the id the account has now.
+     *
+     * A pin or a hide written before the identity fix names its account by the
+     * old name-derived key. Kept in step by {@link read}, which every routing
+     * decision goes through, so the mapping is never stale when it is consulted.
+     */
+    private readonly legacyIds;
+    /**
+     * Per-model parks, in memory only: account id → model → the instant it lifts.
+     *
+     * The subscription meters an account × MODEL over a 24h window (429 `code
+     * 6004` names when it lifts), so cooling the whole ACCOUNT for one exhausted
+     * model throws away every other model that account can still serve. Process
+     * local on purpose, like the sibling gateway's model cooldowns: the window is
+     * short, and a restart re-measures it with the first request rather than
+     * trusting a stale timestamp.
+     */
+    private readonly modelCooldowns;
+    /**
+     * Whole-pool state as of the LAST load through {@link loadPoolData}.
+     *
+     * A cache rather than a read per check: eligibility runs once per account per
+     * pick, and asking the encrypted store each time would pay a DPAPI unprotect
+     * per candidate. Every read and every mutation loads the document first, so
+     * this cannot be stale for longer than one storage round trip.
+     */
+    private restrictions;
+    private pause;
+    constructor(options?: WorkBuddyAccountPoolOptions);
+    /**
+     * Load the pool, refreshing the legacy-key index on the way.
+     *
+     * Every routing decision and mutation goes through this method before it
+     * consults the settings selection, so building the index here is what keeps
+     * a pin written before the identity fix resolvable when
+     * {@link resolveSelectionId} is asked for it.
+     */
+    protected loadPoolData(): Promise<PoolData<WorkBuddyPoolAccount>>;
+    /** Keep the pool-wide cache in step with the document just loaded. */
+    private observePoolState;
+    /** This account's live `11140`, matched through every key it answers to. */
+    private restrictionFor;
+    /** The pause that is still running, or undefined when it lifted or never began. */
+    private activePause;
+    /** The error every selection raises while the pool is paused. */
+    private pausedError;
+    /**
+     * Record an account-scoped refusal reported by the protocol worker.
+     *
+     * This is the ONE entry point for `11140`, and the policy it implements is
+     * the confirmed Wave 2A one:
+     *
+     * - the first barred account leaves rotation immediately and its restriction
+     *   is PERSISTED (in the pool document, so a second pool instance over the
+     *   same store sees it), while every other account keeps serving;
+     * - a SECOND, different account barred within
+     *   {@link WORKBUDDY_RESTRICTION_ESCALATION_WINDOW_MS} pauses the whole pool
+     *   for {@link WORKBUDDY_POOL_PAUSE_MS} — during which no account is selected
+     *   at all — and that pause is persisted too;
+     * - the pause lifts by itself, the restricted accounts do NOT: only a
+     *   completed sign-in ({@link addAccount}) puts one back in rotation.
+     *
+     * Only {@link WORKBUDDY_RESTRICTED_ACCOUNT_CODE} is accepted. `11128` is the
+     * channel/request-shape block and `11158` is one model an account has no
+     * entitlement for; neither says the ACCOUNT may not serve, so recording either
+     * would take a working account out of rotation and — with two inside the
+     * window — stop the whole pool over a request-shape mistake. The call is
+     * therefore refused loudly, which keeps that misrouting visible in a test or a
+     * log instead of silently barring a healthy account.
+     */
+    markAccountRestriction(accountId: string, restriction: WorkBuddyAccountRestrictionDto): Promise<void>;
+    /** Clear one account's restriction; a completed sign-in is what does this. */
+    private clearRestriction;
+    /**
+     * Whole-pool state for the wire: whether the pool is paused, why, until when,
+     * which accounts are barred, and where this document lives.
+     *
+     * `pausedUntil` is the pause's remaining time in absolute form, which is what
+     * a card can count down and a route can answer without a second call. An
+     * expired pause is reported as not paused — it never needs a write to lift.
+     */
+    poolState(): Promise<WorkBuddyPoolStateDto>;
+    /** Map a settings key from before the identity fix onto the account's real id. */
+    private resolveSelectionId;
+    /**
+     * Adopt any desktop credential the pool does not know yet.
+     *
+     * The IDE's directory is the source of truth for its own accounts, so a
+     * credential that appears there joins the pool. Nothing is ever removed: a
+     * file that disappears (the IDE signed out, a profile was moved) leaves the
+     * account in place, where the user can hide or delete the managed ones.
+     */
+    syncDesktopAccounts(): Promise<WorkBuddyAccountSummaryDto[]>;
+    /**
+     * A stale `authStatus` is cleared once the credential in force has moved on.
+     *
+     * The marker records that ONE token was refused; it does not record that the
+     * sign-in is gone. This line can still produce it from a token-endpoint
+     * refusal, and the copy that refusal was about can be replaced afterwards by
+     * whoever owns it — the IDE rotates a desktop account's token on its own
+     * schedule, and the daily check-in renews a managed one and writes it back to
+     * this plugin's store. Nothing else in the system ever revisits an
+     * `authStatus`, so without this a row stays out of rotation for good and the
+     * card keeps saying "需要重新登录" for an account that is signed in.
+     *
+     * The verdict is re-checked against what the store holds NOW: a row whose
+     * account has a DIFFERENT, unexpired token is routable again and adopts it,
+     * while a row still holding the refused token keeps its marker — that one
+     * really does need a sign-in.
+     */
+    private healStaleAuthFailures;
+    /** Account summaries, with a marker the credentials have outlived cleared. */
+    listAccounts(): Promise<WorkBuddyAccountSummaryDto[]>;
+    /**
+     * Pick an account, healing a stale marker first.
+     *
+     * The healing belongs on the request path, not only on the card: an account
+     * marked expired is excluded by the core's eligibility rule, so until the
+     * marker is gone the next request is answered with "全部 N 个账号都需要重新登录"
+     * for a credential the store has already replaced.
+     */
+    getEffectiveAccount(excludeIds?: ReadonlySet<string>, fetchFn?: typeof fetch, forceRefresh?: boolean): Promise<{
+        account: WorkBuddyPoolAccount;
+        credentials: WorkBuddyCredentials;
+    }>;
+    /**
+     * Pick the account for the next request.
+     *
+     * A desktop account's credential is re-read from the IDE's file first: the IDE
+     * refreshes its own token, so the copy the pool adopted can be older than what
+     * is on disk.
+     */
+    getEffectiveCredential(excludeIds?: ReadonlySet<string>, fetchFn?: typeof fetch, model?: string): Promise<{
+        account: WorkBuddyPoolAccount;
+        credentials: WorkBuddyCredentials;
+    }>;
+    /**
+     * Park ONE model on one account; every other model keeps serving.
+     *
+     * Returns the instant the park lifts, or undefined for a non-positive
+     * duration (which clears any existing park rather than extending it).
+     */
+    markModelCooldown(accountId: string, model: string, durationMs: number): number | undefined;
+    /** When this account's park on this model lifts, or undefined when it may serve. */
+    modelCooldownUntil(accountId: string, model: string, now?: number): number | undefined;
+    /**
+     * The models this account is parked on right now, with the instant each park
+     * lifts.
+     *
+     * Only LIVE parks are reported: a window that has passed is dropped here, so
+     * the card never shows a model that may already serve. The lift instant is
+     * the one the upstream named, stored verbatim by
+     * {@link markModelCooldown}; it is never recomputed from a duration that has
+     * since drifted, because a re-derived instant would drift with it.
+     */
+    private liveModelCooldowns;
+    /**
+     * Clear one account's cooldown AND the models it is parked on.
+     *
+     * The card's "reset cooldown" button promises the account is usable again. A
+     * model park is a cooldown too — the account stays eligible, but it still
+     * refuses the model the request wants — so leaving the park behind would
+     * report a reset that did not happen, and the park would outlive the only
+     * control the user has over it.
+     *
+     * The base write comes first: it is the half that can fail, and a failed
+     * write must leave the account's state as it was rather than half-cleared.
+     */
+    clearCooldown(accountId: string): Promise<void>;
+    /** Accounts currently parked on one model, with lifted entries pruned on the way. */
+    private parkedAccountIds;
+    /**
+     * Whether another account besides `triedAccountIds` can serve THIS model.
+     *
+     * The plain {@link hasAnotherAvailableAccount} answers for any model, so a
+     * rotation loop that consulted it would keep trying while every remaining
+     * account is parked on the model it is asking for — turning one exhausted
+     * window into a burst of refused requests.
+     */
+    hasAnotherAvailableAccountFor(triedAccountIds: ReadonlySet<string>, model: string): Promise<boolean>;
+    /**
+     * Whether another account may serve right now.
+     *
+     * Answered from ONE read that also carries the pool-wide state, and false
+     * while the pool is paused: the rotation loop consults this before retrying,
+     * so a pause has to end the loop there rather than after another selection it
+     * would only refuse.
+     */
+    hasAnotherAvailableAccount(triedAccountIds: ReadonlySet<string>): Promise<boolean>;
+    /**
+     * Whether an account may serve a request.
+     *
+     * A hidden account keeps its place, its alias and its history, but the user
+     * has taken it out of this plugin's rotation, so it is not eligible.
+     */
+    protected isEligible(account: WorkBuddyPoolAccount, now: number, triedAccountIds?: ReadonlySet<string>): boolean;
+    private selection;
+    /**
+     * Add or re-authorize one account, settling its identity first.
+     *
+     * A completed browser sign-in states the display name but not always the uid,
+     * while the IDE's own file for the same account states the uid. Passing the
+     * raw response through would key the login under the name and the file under
+     * the uid, so the pool would hold the same account twice — the duplicate this
+     * fix exists to remove. Resolving from the credential's own token before the
+     * dedupe key is computed is what makes the two paths agree.
+     */
+    addAccount(credentials: WorkBuddyCredentials, alias?: string): Promise<WorkBuddyPoolAccount>;
+    /**
+     * Remove one account inside a transaction.
+     *
+     * A desktop account is refused: the plugin does not own that credential file,
+     * so removing it from the pool would strand the IDE's session while telling
+     * the user their account was deleted. Hiding is the supported action there.
+     */
+    protected deleteAccountFromPool(data: PoolData<WorkBuddyPoolAccount>, accountId: string): void;
+}
+//# sourceMappingURL=account-pool.d.ts.map

package/lib/types/host/workbuddy/account-pool.d.ts.map

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

package/lib/types/host/workbuddy/adapter.d.ts

@@ -0,0 +1,249 @@
+import { LlmAdapter, LlmError, ReasoningEffortId, type GenerateOptions, type LlmModelInfo, type LlmProviderInfo, type LlmResolvedModelInfo, type PreparedAdapterCall, type ResolvedRetryPolicy, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import { PROVIDER_ID, PROVIDER_NAME } from './types.ts';
+import { FileCredentialStore, FileModelSettingsStore, type WorkBuddyPreferenceStore } from './token-store.ts';
+import { type WorkBuddyModelEntry } from './model-catalog.ts';
+import { type AttachmentImageReader } from './mapper.ts';
+import { type WorkBuddyAccountRestrictionDto } from '../../shared/workbuddy-contracts.ts';
+import type { WorkBuddyCredentials } from './token-store.ts';
+import { type WorkBuddyUsageLedger } from './guardrails.ts';
+/**
+ * Effort this route materializes when the caller names none.
+ *
+ * Preference order: the user's configured level when the model accepts it,
+ * otherwise the level the gateway's own catalog declares for that model (the
+ * same default the official CLI applies), otherwise nothing — which leaves the
+ * provider's own default in charge. A configured level the model does not
+ * accept is ignored rather than sent, since the endpoint rejects an unsupported
+ * level with `code 11150`.
+ */
+export declare function resolveDefaultReasoningEffort(efforts: readonly string[], configuredEffort?: string | null, modelDefaultEffort?: string | null): ReasoningEffortId | undefined;
+/** Cooldown a 429 imposes when the service names no reset instant. */
+export declare const POOL_COOLDOWN_MS: number;
+/**
+ * The account pool this adapter drives, declared STRUCTURALLY.
+ *
+ * The pool module (`account-pool.ts`) and the settings routes are outside this
+ * file's boundary — Wave 3 owns them — so the adapter cannot import the class.
+ * Declaring the shape it calls has one property that matters here: this file is
+ * typechecked against the CONTRACT, so a method renamed on the pool side fails
+ * the build instead of failing at run time in the middle of a rotation loop.
+ *
+ * `markAccountRestriction` is the one member the pool worker FROZE for Wave 2B:
+ * code 11140 is an account verdict (who is asking), not a model verdict, and a
+ * `cooldownUntil` on the account or on a model cannot express "this account is
+ * barred from everything".
+ */
+export interface WorkBuddyAccountPool {
+    listAccounts(): Promise<readonly {
+        id: string;
+    }[]>;
+    getEffectiveCredential(tried: ReadonlySet<string>, fetchFn: typeof fetch, model?: string): Promise<{
+        account: {
+            id: string;
+        };
+        credentials: WorkBuddyCredentials;
+    }>;
+    renewCredential(accountId: string, fetchFn: typeof fetch, current: WorkBuddyCredentials): Promise<WorkBuddyCredentials>;
+    hasAnotherAvailableAccount(tried: ReadonlySet<string>): Promise<boolean>;
+    hasAnotherAvailableAccountFor(tried: ReadonlySet<string>, model: string): Promise<boolean>;
+    markCooldown(accountId: string, ms: number, reason: string): Promise<unknown>;
+    markModelCooldown(accountId: string, model: string, until: number): void;
+    /** Freeze this account out of every model after code 11140. */
+    markAccountRestriction(accountId: string, restriction: WorkBuddyAccountRestrictionDto): Promise<void>;
+}
+/**
+ * The pool's own "everything is stopped" error.
+ *
+ * Read structurally (by `name`) rather than by `instanceof`: the class lives in
+ * the pool module this file may not import, and a plugin build that loaded the
+ * pool and the adapter through two module instances would fail an `instanceof`
+ * check that the name comparison passes.
+ */
+export interface WorkBuddyPoolPausedErrorLike extends Error {
+    name: 'WorkBuddyPoolPausedError';
+    /** Why the whole pool is stopped; composed by the host, never a token. */
+    pauseReason?: string;
+    /** Unix milliseconds the pause lifts on its own, when it does. */
+    pausedUntil?: number;
+}
+/** Whether one thrown value is the pool's whole-pool pause. */
+export declare function isPoolPausedError(error: unknown): error is WorkBuddyPoolPausedErrorLike;
+/**
+ * Which of the account's models the picker may offer.
+ *
+ * The stored list is kept relative to what the ACCOUNT can serve, and the
+ * shipped default is not a stored preference: a user who never visited the
+ * picker has exactly the shipped defaults stored, and that state has to mean
+ * "everything this account can serve" — otherwise a model the catalog gained
+ * after the last visit would be hidden from someone who never hid it.
+ */
+export declare function resolveEnabledModelIds(stored: readonly string[], available: readonly string[], enabled?: boolean): string[];
+/** Most system texts this process remembers (FIFO beyond it). */
+export declare const REFUSED_SYSTEM_MEMORY_LIMIT = 256;
+/** Remember one refused system text, evicting the oldest past the limit. */
+export declare function rememberRefusedSystemKey(key: string): void;
+/** Whether this process has already been refused for that system text. */
+export declare function refusedSystemKeyKnown(key: string): boolean;
+/** How many system texts are remembered (test and diagnostics seam). */
+export declare function refusedSystemKeyCount(): number;
+/** Forget every remembered refusal (test seam; never called by the adapter). */
+export declare function clearRefusedSystemKeys(): void;
+export interface WorkBuddyAdapterOptions {
+    /**
+     * Per-account daily token counters behind the local guardrails.
+     *
+     * Absent means the guardrails cannot be evaluated, so a deployment without it
+     * never refuses a request for a reason nothing is counting.
+     */
+    usageLedger?: WorkBuddyUsageLedger;
+    fetchFn?: typeof fetch;
+    attachments?: AttachmentImageReader;
+    /** Live catalog loader seam; defaults to the gateway `/v3/config` call. */
+    loadCatalog?: (credentials: WorkBuddyCredentials) => Promise<WorkBuddyModelEntry[]>;
+    /**
+     * Multi-account pool this adapter rotates through.
+     *
+     * Absent leaves the line on its single-credential path, which is what the
+     * headless tests and any caller that predates the pool use.
+     */
+    accountPool?: WorkBuddyAccountPool;
+}
+export declare class WorkBuddyAdapter extends LlmAdapter {
+    private readonly store;
+    private readonly modelSettings;
+    private readonly preferences?;
+    private readonly options;
+    /** Null keeps the pre-pool single-credential path. */
+    private readonly accountPool;
+    constructor(store?: FileCredentialStore, modelSettings?: FileModelSettingsStore, preferences?: WorkBuddyPreferenceStore | undefined, options?: WorkBuddyAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(): ResolvedRetryPolicy;
+    imageRequestPricing(): undefined;
+    /**
+     * Request version the harness should hand this route for one image.
+     *
+     * This is the other half of the request image budget and it has to come from
+     * the same place: the shared kernel decides the target (long edge 1024,
+     * 256 KiB per image) and the shared budget decides what still fits, so a
+     * mapper cannot ask for a target the harness does not produce, and cannot
+     * send an image the kernel already paid to downscale. Answering undefined
+     * here used to mean send-as-stored while the mapper applied its own private
+     * 12 MB ceiling, which is exactly the drift this pairing removes.
+     */
+    imageRequestTarget(_provider: string, _model: string, image: ImageAttachmentRef): {
+        width: number;
+        height: number;
+        maxBytes: number;
+    };
+    private settings;
+    private credentials;
+    /**
+     * Catalog for the picker: the live gateway listing when reachable, the
+     * shipped table otherwise.
+     *
+     * The gateway is the authority on capabilities, so its answer replaces the
+     * fallback rather than merging with it — a model whose context window changed
+     * upstream must not keep a stale local value.
+     */
+    private catalog;
+    /**
+     * Models the picker may offer.
+     *
+     * The catalog is filtered by the account's own region: asking a region for a
+     * model it does not serve answers 400 `code 11102`, so offering one would
+     * hand the user a model that cannot work.
+     */
+    listModels(provider?: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, modelId: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /**
+     * Effort this request should carry, or `undefined` to send none.
+     *
+     * Order: the caller's explicit choice, then the user's configured level, then
+     * the level the gateway catalog declares for this model. The last step
+     * matters because the endpoint returns an **empty `reasoning_content`** when
+     * no `reasoning_effort` is present, even for a reasoning-only model: measured
+     * on `deepseek-v4.1-flash`, the same prompt yields 0 reasoning characters
+     * with no field and 130-215 with one. Omitting it therefore silently drops
+     * the model's thinking instead of letting the provider pick, so the catalog's
+     * own default (which is what the official CLI sends) is materialized here.
+     *
+     * A candidate the model does not accept is discarded rather than sent, since
+     * the endpoint rejects an unsupported level with `code 11150`.
+     */
+    /**
+     * Accounts the LOCAL guardrails refuse for this model right now.
+     *
+     * Reads only numbers this plugin already owns — the billing snapshot's
+     * remaining credits and this line's own token counters — so it never becomes a
+     * second, disagreeing source of truth about the upstream allowance.
+     */
+    private guardrailBlockedAccounts;
+    private effortFor;
+    private requestStream;
+    /**
+     * Re-read the stored credential, for a token another process may have written.
+     *
+     * The desktop app and any sibling plugin share this directory, and a token
+     * written there is already the newest one available: refreshing over it would
+     * rotate the account's refresh token out from under whoever signed in last.
+     * A failed read answers null — it is a fallback, not a verdict.
+     */
+    private rereadCredential;
+    /**
+     * Count this request's billed tokens off its usage frame.
+     *
+     * Both protocols send exactly one usage frame at the end; the cache counts are
+     * added back because the aggregate the surfaces report excludes them, so a
+     * cached turn would otherwise be recorded as almost free.
+     */
+    private countedChunks;
+    /**
+     * Read one SSE body into chunks, protocol-agnostically.
+     *
+     * Bytes on the wire are the liveness signal: a heartbeat or status frame that
+     * produces no displayable chunk still proves the connection is alive, so the
+     * watchdog timer is reset at the transport layer, not at the parser.
+     */
+    private drainStream;
+}
+/**
+ * The failure a 11140 is reported as.
+ *
+ * Account-scoped, so it is classified apart from every model-scoped refusal: the
+ * message says the ACCOUNT is barred (not that a model is unavailable, not that
+ * a quota window is full), because the fix is a different account or a release
+ * from the service, and no retry can help.
+ */
+export declare function accountRestrictedFailure(detail: string, status: number): LlmError;
+/**
+ * Map one failed HTTP response onto a DSH failure.
+ *
+ * The subscription reports its own conditions inside a JSON `code` while the
+ * status line stays generic, so the body is read for the specific cases the
+ * status alone cannot express — notably the quota signal, whose message carries
+ * the instant the allowance resets.
+ */
+export declare function classifyFailure(status: number, detail: string, headers?: Headers): LlmError;
+/**
+ * The reset instant a quota refusal names, as a delay from now.
+ *
+ * A 24h allowance that is exhausted answers 429 / `code 6004` with the wall
+ * clock it lifts — but only in the MESSAGE, never in a header, and in two
+ * realm-specific wordings (measured: intl "… resets at 2026-09-20 10:50:48
+ * UTC+8", cn "… 将在 2026-10-09 14:44:59 UTC+8 重置"). Reading the status alone
+ * therefore loses the only fact that says how long the account is out, and the
+ * pool parks a 24-hour limit for five minutes before trying it again.
+ *
+ * Deliberately tolerant, in the same direction as their gateway: an unparseable
+ * body yields `undefined` (callers keep their default cooldown) rather than an
+ * error, because this runs on a failure path. An absent `UTC±h` marker means
+ * UTC, which is how the sibling implementation reads it too.
+ */
+export declare function readRateLimitReset(detail: string, now?: number): number | undefined;
+/** Read the subscription's own numeric error code out of a response body. */
+export declare function readErrorCode(detail: string): number | null;
+export { PROVIDER_ID, PROVIDER_NAME };
+//# sourceMappingURL=adapter.d.ts.map

package/lib/types/host/workbuddy/adapter.d.ts.map

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