@eddyskywalker/dsh-chatgpt-subscription 0.10.0 → 0.10.1

package/lib/types/host/minimax-code/mapper.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Provider-wire mapping for the MiniMax Code subscription.
+ *
+ * The subscription speaks Anthropic Messages, so this file builds a
+ * \`/messages\` body and normalizes the SSE stream back into DSH's block/delta
+ * vocabulary.
+ *
+ * WHAT IS REUSED, AND WHAT IS NOT
+ *
+ * The generic halves of this problem already exist beside it in
+ * \`../kimi-code/mapper.ts\` and are imported rather than reimplemented: durable
+ * image resolution, the image budget that drops the oldest attachments first,
+ * JSON-Schema cleanup for tool parameters, and the serialized-body guard. None of
+ * those is provider-specific, and having one implementation is what keeps the two
+ * lines from drifting.
+ *
+ * The provider-specific halves are written here:
+ *
+ * - the thinking control. The subscription's own model table names its thinking
+ *   vocabulary (M2.7 always on with no level, M3 a two-state switch, M3.1 forced
+ *   on with a level), which is not Kimi's low/high/max ladder; and
+ * - every diagnostic string, because an error a user reads must name the service
+ *   they are actually talking to.
+ *
+ * WHAT IS MEASURED AND WHAT IS INFERRED
+ *
+ * Measured (brief sections 2.1 and 2.3): the endpoint, the URL shape
+ * \`<base>/mavis/api/v1/llm/v1/messages\`, the bearer header, the Anthropic
+ * protocol revision, the request body \`{model, max_tokens, messages}\` answering
+ * 200, and the four usage counters in the response.
+ *
+ * Inferred, and isolated in \`thinkingFieldFor\` so it is the only thing to change if
+ * it is ever contradicted: the \`thinking\` object's exact shape. The model table
+ * describes thinking as a state ("none-thinking / thinking") and, for M3.1, as an
+ * \`effort\` level, so the field is emitted in that vocabulary and nowhere else. No
+ * other undocumented field is ever sent.
+ *
+ * UNRESOLVED, AND DELIBERATELY NOT ACTED ON: prompt caching.
+ *
+ * No `cache_control` marker is ever sent, yet this file reads the two cache
+ * counters out of `usage` (see the message_start branch) - so the route is
+ * prepared to report cache hits it never asks for. MiniMax documents two
+ * different mechanisms, and they are not interchangeable:
+ *
+ * - an AUTOMATIC cache on its native API, which needs no marker at all; and
+ * - an EXPLICIT cache on its Anthropic-compatible API, where the
+ *   `cache_control` breakpoints are what create the cache at all
+ *   (`tools` -> `system` -> `messages`, per the "Explicit Prompt Caching
+ *   (Anthropic API)" page of the MiniMax docs).
+ *
+ * This line speaks the Anthropic dialect, so the explicit mechanism may well be
+ * the one that applies - but the subscription endpoint is NOT the public API
+ * (`<base>/mavis/api/v1/llm/v1/messages` vs `api.minimax.io/anthropic`), and its
+ * caching behaviour has never been measured here. Adding a marker is not free
+ * either: `system` is a plain string on this line, so a system-level breakpoint
+ * means changing that field into an array of blocks, and a marker on a block the
+ * wire does not accept can fail the whole request - the same class of total
+ * failure the missing `stream: true` caused.
+ *
+ * So the marker stays out until one live request settles it: send a body with
+ * and without a breakpoint and compare `cache_read_input_tokens`. The shape to
+ * copy once that is measured is the Claude line's, which marks only a block the
+ * wire accepts and states the intent at the call site because caching there is
+ * request-driven (`claude/mapper.ts`, `claude/adapter.ts`).
+ */
+import { type ContentBlock, type OutboundContentBlock, type GenerateOptions, type StreamChunk } from '../common/llm-compat.ts';
+import { MAX_MESSAGE_BODY_BYTES, estimatedInputTokens, offloadOldestRequestImages, resolveRequestImages, type AttachmentImageReader, type ResolvedRequestImages } from '../kimi-code/mapper.ts';
+import { ANTHROPIC_VERSION } from './types.ts';
+export { MAX_MESSAGE_BODY_BYTES, estimatedInputTokens, offloadOldestRequestImages, resolveRequestImages };
+export type { AttachmentImageReader, ResolvedRequestImages };
+/**
+ * The thinking control for one request.
+ *
+ * This is the single inferred field in the builder, and it is kept to the
+ * vocabulary the subscription's own model table uses:
+ *
+ * - \`always-on\` (M2.7, M2.7-highspeed): nothing is sent. The model always thinks
+ *   and has no level, so any field would be decoration at best and a rejected one
+ *   at worst;
+ * - \`toggle\` (M3): the table names the two states "none-thinking / thinking", so
+ *   the off state is the explicit disable and the on state is what a request that
+ *   says nothing already gets;
+ * - \`forced-effort\` (M3.1-Flash-Preview): thinking is forced on and the table
+ *   gives the level in an \`effort\` field, so the level travels there.
+ *
+ * A caller asking for a level the model does not list is mapped to the model's
+ * documented default by \`effortForModel\` before it reaches here.
+ */
+export declare function thinkingFieldFor(modelId: string, requestedEffort: string | undefined | null): Record<string, unknown> | undefined;
+/** Output cap one request asks for, tracked against the model's declared ceiling. */
+export declare function maxOutputTokensFor(modelId: string, contextWindow?: number): number;
+/** Reduce a requested cap so prompt plus output still fit the window. */
+export declare function clampOutputToContext(requested: number, contextWindow: number, estimatedInputTokens?: number): number;
+/** Build one Anthropic Messages body for this subscription. */
+export declare function buildMinimaxRequest(options: GenerateOptions, images?: ResolvedRequestImages): Record<string, unknown>;
+/**
+ * Reject a request the service would refuse, before sending it.
+ *
+ * @returns the serialized body, so the caller about to send it does not serialize
+ * a multi-megabyte string a second time.
+ */
+export declare function assertRequestBodyFits(body: Record<string, unknown>): string;
+/** One tool call accumulating across content-block deltas. */
+interface PendingToolCall {
+    blockIndex: number;
+    id: string;
+    name: string;
+    arguments: string;
+}
+/** Stream accumulator for one Messages response. */
+export interface MinimaxStreamState {
+    blocks: OutboundContentBlock[];
+    current: {
+        index: number;
+        type: 'text' | 'reasoning';
+        text: string;
+    } | null;
+    /** wire content-block index -> accumulating call. */
+    toolCalls: Map<number, PendingToolCall>;
+    /** wire content-block index -> our block index. */
+    contentIndexes: Map<number, number>;
+    hasContent: boolean;
+    hasToolCall: boolean;
+    finishReason: string | null;
+    done: boolean;
+    finished: boolean;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    sawUsage: boolean;
+}
+export declare function createStreamState(): MinimaxStreamState;
+/** Flush every open block, then emit usage and the terminal finish. */
+export declare function closeMinimaxStream(state: MinimaxStreamState): StreamChunk[];
+/** Raise when a stream ended without the terminal event the protocol promises. */
+export declare function assertStreamComplete(state: MinimaxStreamState): void;
+/** Feed one SSE line from the Messages endpoint. */
+export declare function processMinimaxStreamLine(line: string, state: MinimaxStreamState): StreamChunk[];
+/** Whether one chunk stream carried any assistant content at all. */
+export declare function streamHasContent(state: MinimaxStreamState): boolean;
+export { ANTHROPIC_VERSION, type ContentBlock };
+//# sourceMappingURL=mapper.d.ts.map

package/lib/types/host/minimax-code/mapper.d.ts.map

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

package/lib/types/host/minimax-code/model-catalog.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Hardcoded catalog of the models the MiniMax Code subscription serves.
+ *
+ * This catalog is hardcoded on purpose. The endpoint documents a
+ * `GET /v1/models` route, but it is not configured for subscription traffic and
+ * answers 503 `{"errorCode":50115,"errorReason":"direct_route_not_configured"}`
+ * (and 401 when queried with `x-api-key`). Nothing in this package may probe it,
+ * at startup or otherwise.
+ *
+ * The four entries and every number in them are transcribed verbatim from the
+ * model table in `~/.minimax/config.yaml` (brief section 2.3). No value here is
+ * inferred from another provider's catalog.
+ */
+import type { MinimaxCodeModelOption, MinimaxCodeReasoningEffort } from '../../shared/minimax-code-contracts.ts';
+/**
+ * How one model's thinking behaves.
+ *
+ * - `always-on`    — thinking cannot be turned off and has no selectable level;
+ * - `toggle`       — thinking is on by default and can be disabled;
+ * - `forced-effort` — thinking is forced on and a level can be selected.
+ */
+export type MinimaxCodeThinkingMode = 'always-on' | 'toggle' | 'forced-effort';
+/** One model the MiniMax Code subscription serves. */
+export interface MinimaxCodeCatalogModel {
+    /** Exact model id to put on the wire. */
+    id: string;
+    /** Display name shown in the picker. */
+    name: string;
+    /** Context window the account is entitled to by default. */
+    contextWindow: number;
+    /** Larger window the model can reach, when one is offered as an option. */
+    optionalContextWindow: number | null;
+    /** Output cap the model accepts. */
+    maxTokens: number;
+    /**
+     * Input the model accepts.
+     *
+     * Declared as the wire accepts it. Note that a capability listed here is a claim
+     * DSH's capability pipeline acts on (prompt admission, the model picker, subagent
+     * delegation), so this line lists only what its mapper can actually put on the
+     * wire. Video is deliberately NOT listed even though the model table documents it
+     * on M3 and M3.1: DSH's attachment service is image-only and this line installs no
+     * video byte reader, so a clip that reached the mapper would be replaced by a
+     * placeholder — advertising it would promise an upload the route cannot perform.
+     * Add 'video' here only together with a real reader (see the Kimi Code line, which
+     * implements one in `video-store.ts` and widens the modality vocabulary for it).
+     */
+    inputModalities: readonly ('text' | 'image')[];
+    /** How thinking behaves on this model. */
+    thinking: MinimaxCodeThinkingMode;
+    /**
+     * Levels the model accepts, in escalating order.
+     *
+     * A single `default` entry means the model has no selectable level: the picker
+     * shows one always-on option rather than inventing a gradient the model does
+     * not document.
+     */
+    reasoningEfforts: readonly MinimaxCodeReasoningEffort[];
+    /** Level used when the conversation does not pick one. */
+    defaultReasoningEffort: MinimaxCodeReasoningEffort;
+    /** Attachments one request may carry, when the model states a bound. */
+    maxAttachments: number | null;
+    /** Largest single image the model accepts, in bytes. */
+    maxImageBytes: number | null;
+    /** Largest single video the model accepts, in bytes. */
+    maxVideoBytes: number | null;
+    /** Whether the model is served through the subscription's files API. */
+    supportsFilesApi: boolean;
+    /** One-line description, from the model table. */
+    description: string;
+}
+/**
+ * The four ids the subscription serves today.
+ *
+ * `MiniMax-M3` is the durable default: it is the flagship the measured request
+ * used, and it is the one model whose wire behaviour is directly attested.
+ */
+export declare const MINIMAX_CODE_MODELS: readonly MinimaxCodeCatalogModel[];
+/** Registry entry for one model id, or undefined when the id is unknown. */
+export declare function minimaxCodeModelDef(modelId: string): MinimaxCodeCatalogModel | undefined;
+/** Membership test for one known model id. */
+export declare function isMinimaxCodeModelId(value: unknown): boolean;
+/** Display name for one model id, falling back to the raw id so nothing is hidden. */
+export declare function minimaxCodeModelName(modelId: string): string;
+/** Every model id the picker offers, in catalog order. */
+export declare function minimaxCodeModelIds(): string[];
+/**
+ * Whether one effort id means "thinking off".
+ *
+ * The subscription table spells the disabled state "none-thinking" while the
+ * shared contract's effort vocabulary has no such member, so a caller that
+ * nevertheless asks for an off state (an older preference file, a hand-built
+ * request) is recognized here rather than silently treated as "on".
+ */
+export declare function isThinkingDisabledEffort(value: unknown): boolean;
+/**
+ * The effort level to put on the wire for one model.
+ *
+ * An unknown or off value falls back to the model's documented default, so a
+ * caller cannot talk this route into a level the model does not list.
+ */
+export declare function effortForModel(modelId: string, requested: string | undefined | null): MinimaxCodeReasoningEffort;
+/**
+ * Smallest context window an override may name.
+ *
+ * Exported because the settings route validates POSTed overrides against the
+ * same number this reader uses: if they drifted, the route would accept a value
+ * the reader then treats as absent, and the card would show a saved override
+ * that silently does nothing.
+ */
+export declare const MIN_CONTEXT_WINDOW = 1000;
+/**
+ * The effective context window for one model.
+ *
+ * One reader for both the status card and the request path, because the two
+ * disagreeing is the exact failure this override can cause: the card would show
+ * a window the request builder then ignored, and the user would see a request
+ * clamped to the catalog's number with nothing on screen explaining why.
+ *
+ * A non-positive or sub-minimum override is treated as absent rather than
+ * clamped: the route never stores one (it validates them), so seeing one means
+ * the document was hand-edited, and inventing a window from it would size every
+ * request on that model against a number the user never chose.
+ */
+export declare function contextWindowForModel(modelId: string, contextWindowOverrides: Record<string, number> | undefined): number;
+/**
+ * The catalog ids the user's stored selection actually resolves to.
+ *
+ * A stored list that still equals the shipped default has never been edited, so
+ * it cannot know about models a later release added; treating it as "everything
+ * the catalog currently offers" is what keeps a first run from hiding a new
+ * model behind an unedited default. Any explicit edit is honoured exactly, and
+ * an id the catalog no longer serves is dropped so the picker cannot offer a
+ * model this build has no entry for.
+ */
+export declare function resolveMinimaxCodeEnabledModelIds(stored: readonly string[], enabled?: boolean): string[];
+/**
+ * The settings-card rows for the whole shipped catalog.
+ *
+ * Every model is present, enabled or not: the card toggles rows, so a disabled
+ * model has to be rendered to be re-enabled. `contextWindow` is the effective
+ * window and `defaultContextWindow` the catalog's own number, which is what lets
+ * the card show a modified row as modified.
+ */
+export declare function buildMinimaxCodeModelOptions(storedEnabledModelIds: readonly string[], contextWindowOverrides: Record<string, number>, enabled?: boolean): MinimaxCodeModelOption[];
+//# sourceMappingURL=model-catalog.d.ts.map

package/lib/types/host/minimax-code/model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/model-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAE3B,MAAM,wCAAwC,CAAA;AAI/C;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAA;AAE9E,sDAAsD;AACtD,MAAM,WAAW,uBAAuB;IACtC,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAA;IACrB,2EAA2E;IAC3E,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAA;IACpC,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAA;IAC9C,0CAA0C;IAC1C,QAAQ,EAAE,uBAAuB,CAAA;IACjC;;;;;;OAMG;IACH,gBAAgB,EAAE,SAAS,0BAA0B,EAAE,CAAA;IACvD,0DAA0D;IAC1D,sBAAsB,EAAE,0BAA0B,CAAA;IAClD,wEAAwE;IACxE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,wDAAwD;IACxD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,wDAAwD;IACxD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,wEAAwE;IACxE,gBAAgB,EAAE,OAAO,CAAA;IACzB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,uBAAuB,EAqEjE,CAAA;AAID,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CAExF;AAED,8CAA8C;AAC9C,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE5D;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,0DAA0D;AAC1D,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAIhE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GACnC,0BAA0B,CAO5B;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,OAAQ,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACzD,MAAM,CAOR;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,UAAO,GACb,MAAM,EAAE,CAOV;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,qBAAqB,EAAE,SAAS,MAAM,EAAE,EACxC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9C,OAAO,UAAO,GACb,sBAAsB,EAAE,CAoB1B"}

package/lib/types/host/minimax-code/oauth.d.ts

@@ -0,0 +1,204 @@
+/**
+ * OAuth for the MiniMax Code subscription.
+ *
+ * The flow is RFC 8628 device authorization with PKCE(S256) against a public
+ * client (`mcode-public`, no secret) — the shape the desktop app uses, and the
+ * only one that fits a plugin with no browser callback to receive.
+ *
+ * Measured facts that shape this file (brief section 2.5):
+ *
+ * - device authorization: POST `account.minimax.cn/oauth2/device/code`
+ * - token (device grant AND refresh): POST `account.minimax.cn/oauth2/token`
+ * - revocation: POST `account.minimax.cn/oauth2/revoke`
+ * - every call is `application/x-www-form-urlencoded` with `Accept: application/json`
+ * - the device grant carries `code_challenge`/`code_challenge_method=S256` and the
+ *   poll carries the matching `code_verifier`
+ * - the refresh carries `grant_type=refresh_token`, `refresh_token`, `client_id`,
+ *   `scope` and `audience`
+ *
+ * The refresh policy is the one the brief fixes at section 2.6: read the stored
+ * credential first and use it while it is valid, refresh only when it is not (or
+ * when the service has just rejected it), write the rotation back atomically, and
+ * never let a failed refresh damage the file MiniMax Code itself depends on.
+ */
+import type { MinimaxCodeAccount, MinimaxCodeRegion, MinimaxCodeWebLogin } from '../../shared/minimax-code-contracts.ts';
+import { accountHost } from './types.ts';
+import { type MinimaxCodeCredentialStore, type MinimaxCodeCredentials } from './token-store.ts';
+/** Raised when the stored credential was rejected and a new sign-in is required. */
+export declare class MinimaxCodeUnauthorizedError extends Error {
+    constructor(message: string);
+}
+/** Raised when a transient failure outlived its retry budget. */
+export declare class MinimaxCodeRetryableError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/** Raised when the user denied the device authorization request. */
+export declare class MinimaxCodeAccessDeniedError extends Error {
+    constructor(message: string);
+}
+/**
+ * One PKCE pair (RFC 7636).
+ *
+ * The verifier is a fresh random string per authorization; the challenge is its
+ * SHA-256 digest, both base64url encoded with no padding, which is what S256
+ * means on the wire.
+ */
+export declare function createPkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+/** Parsed device authorization response. */
+export interface DeviceAuthorization {
+    userCode: string;
+    deviceCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    expiresIn: number;
+    interval: number;
+    /** PKCE verifier the matching poll must present. */
+    codeVerifier: string;
+    /** Region the authorization was requested in; decides every later host. */
+    region: MinimaxCodeRegion;
+}
+/**
+ * Start a device authorization (RFC 8628 section 3.1).
+ *
+ * A public client sends its `client_id`, the scope and audience it wants, and the
+ * PKCE challenge — no secret, which is the whole point of the device profile.
+ */
+export declare function requestDeviceAuthorization(options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    region?: MinimaxCodeRegion;
+}): Promise<DeviceAuthorization>;
+/** One token response, in the shape the store persists. */
+export interface MinimaxToken {
+    accessToken: string;
+    refreshToken: string;
+    tokenType: string;
+    expiresInSec: number;
+    expiresAtMs: number;
+    scope: string;
+}
+/** Outcome of one device-token poll. */
+export type DevicePollOutcome = {
+    kind: 'success';
+    token: MinimaxToken;
+} | {
+    kind: 'pending';
+    slowDown: boolean;
+} | {
+    kind: 'expired';
+};
+/**
+ * Poll the token endpoint once for one device code (RFC 8628 section 3.4).
+ *
+ * A 5xx is a transport-class failure rather than a verdict on the device code, so
+ * it is raised for the caller's retry loop instead of being read as "still
+ * pending" — treating it as pending would spin against a broken endpoint until the
+ * device code expired.
+ */
+export declare function pollDeviceToken(authorization: Pick<DeviceAuthorization, 'deviceCode' | 'codeVerifier' | 'region'>, options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<DevicePollOutcome>;
+/**
+ * Refresh an access token, with a bounded retry.
+ *
+ * Only a transient status or a transport failure is retried. A 400/401/403, or an
+ * `invalid_grant` body, is a verdict that the refresh token is dead and stops
+ * immediately: retrying it can never succeed, and every attempt is a request the
+ * subscription pays for.
+ */
+export declare function refreshAccessToken(refreshToken: string, options: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    region: MinimaxCodeRegion;
+}): Promise<MinimaxToken>;
+/**
+ * Revoke one token at the service.
+ *
+ * Best effort by design: a revocation that cannot reach the service must not stop
+ * a local sign-out, because the credential is already gone from this machine.
+ */
+export declare function revokeToken(token: string, options: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    region: MinimaxCodeRegion;
+}): Promise<boolean>;
+/** Start a device-code sign-in and hand the card what it must display. */
+export declare function beginWebLogin(options?: {
+    fetchFn?: typeof fetch;
+    region?: MinimaxCodeRegion;
+    signal?: AbortSignal;
+}): Promise<MinimaxCodeWebLogin>;
+/** The public projection of one live sign-in, for the status route. */
+export declare function getWebLogin(loginId: string): MinimaxCodeWebLogin | null;
+/** Cancel one sign-in, dropping the session so a later poll cannot resume it. */
+export declare function cancelWebLogin(loginId: string): boolean;
+/** Forget every session; used by the test seam and by a full sign-out. */
+export declare function resetWebLogins(): void;
+/** Build the account projection one credential yields. */
+export declare function accountFromCredentials(credentials: {
+    loginEpoch: string;
+    generation: number;
+    expiresAtMs: number;
+    region: MinimaxCodeRegion;
+}): MinimaxCodeAccount;
+export { accountHost };
+/** Whether the given refresh token was rejected recently. */
+export declare function isRefreshTokenRejected(refreshToken: string): boolean;
+/** Test seam: forget every remembered rejection. */
+export declare function resetRefreshRejections(): void;
+export interface EnsureTokenOptions {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    /** Refresh even when the stored token is not near expiry (used after a 401). */
+    force?: boolean;
+}
+/**
+ * Return a usable access token, refreshing and writing back only when needed.
+ *
+ * This is the whole of the contention discipline in one function:
+ *
+ * 1. read the stored credential and use it as-is while it is valid — the
+ *    common case, and the one that never touches the file or the network;
+ * 2. refresh only when it is not (or when `force` reports a 401 the service has
+ *    already issued);
+ * 3. share one rotation between concurrent callers, so a burst of tool calls at
+ *    expiry cannot each try to rotate the same refresh token;
+ * 4. write the result back through the store's atomic replacement, and remember a
+ *    rejected token so the next caller is told to sign in instead of retrying.
+ */
+export declare function ensureAccessToken(store: MinimaxCodeCredentialStore, options?: EnsureTokenOptions): Promise<MinimaxCodeCredentials>;
+/**
+ * Poll one live sign-in once and, on success, persist what it produced.
+ *
+ * The persisted credential is plugin-owned: a device-code sign-in started here
+ * has no record in the desktop app's `auth.json` (its record key embeds a hash
+ * this plugin cannot reproduce), so writing a fabricated entry there would leave
+ * the app with an entry it never reads.
+ */
+export declare function pollWebLogin(store: MinimaxCodeCredentialStore, loginId: string, options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    /**
+     * Called with the credential a completed sign-in produced, after it has been
+     * persisted.
+     *
+     * The single-credential store cannot express a second account, so without this
+     * a sign-in started from the card would never join the pool: the pool would
+     * keep serving its existing accounts, and the user's new sign-in would exist
+     * only as the mirror file. The pool installs this hook and adds the credential
+     * as its own account.
+     *
+     * A failure here must not fail the sign-in: the credential is already durable,
+     * and the pool is a routing convenience on top of it. The caller receives the
+     * authenticated verdict either way.
+     */
+    onSave?: (credentials: MinimaxCodeCredentials) => Promise<void>;
+}): Promise<{
+    status: 'pending' | 'authenticated' | 'expired' | 'denied';
+    account?: MinimaxCodeAccount;
+}>;
+//# sourceMappingURL=oauth.d.ts.map

package/lib/types/host/minimax-code/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/oauth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AACxH,OAAO,EAgBL,WAAW,EAIZ,MAAM,YAAY,CAAA;AACnB,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAA;AAEzB,oFAAoF;AACpF,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAED,iEAAiE;AACjE,qBAAa,yBAA0B,SAAQ,KAAK;gBAGtC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAI7C;AAED,oEAAoE;AACpE,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAuDD;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAIxE;AAMD,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;IACvB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAA;IACpB,2EAA2E;IAC3E,MAAM,EAAE,iBAAiB,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,OAAO,GAAE;IACxD,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,MAAM,CAAC,EAAE,iBAAiB,CAAA;CACtB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA6CpC;AAMD,2DAA2D;AAC3D,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd;AAqBD,wCAAwC;AACxC,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAEvB;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,YAAY,GAAG,cAAc,GAAG,QAAQ,CAAC,EAClF,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GAC7D,OAAO,CAAC,iBAAiB,CAAC,CA+B5B;AAoBD;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACnF,OAAO,CAAC,YAAY,CAAC,CAiDvB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACnF,OAAO,CAAC,OAAO,CAAC,CAiBlB;AAmCD,0EAA0E;AAC1E,wBAAsB,aAAa,CAAC,OAAO,GAAE;IAC3C,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAA;CAChB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAoBpC;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CASvE;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED,0DAA0D;AAC1D,wBAAgB,sBAAsB,CACpC,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACtG,kBAAkB,CAQpB;AAGD,OAAO,EAAE,WAAW,EAAE,CAAA;AAsBtB,6DAA6D;AAC7D,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAQpE;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAKD,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CAkDjC;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3D,GACL,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,GAAG,eAAe,GAAG,SAAS,GAAG,QAAQ,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAE,CAAC,CA6DvG"}

package/lib/types/host/minimax-code/routes.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Web routes for the MiniMax Code line.
+ *
+ * The six routes below are the frozen contract the client half consumes (brief
+ * section 3). Their paths, request bodies and verdicts are therefore not free:
+ * this file implements them as specified rather than as this line might prefer.
+ *
+ * Response envelope: every route answers \`{ ok: true, value: <payload> }\`, which is
+ * what the sibling lines in this package use. The three routes whose contract names
+ * a top-level key as well (\`/login/start\` -> \`login\`, \`/login/poll\` -> \`status\` and
+ * \`account\`, \`/test\` -> \`ok\`/\`model\`/\`error\`) carry that key at the top level too,
+ * so a client written against either reading resolves. \`/test\` is the one route
+ * where the envelope's \`ok\` cannot double as the payload's: its contract defines
+ * \`ok\` as the probe verdict, so the envelope there is the verdict itself and the
+ * duplicate lives under \`value\`.
+ *
+ * Mounting: the routes are registered under BOTH the contract prefix and the
+ * sibling-line convention, because the two disagree in this repository and the
+ * client half must not be able to miss them for that reason alone.
+ *
+ * \`/models\` and \`/settings\` are the model-settings half every sibling line has and
+ * this one shipped without. They are two names for one route because the sibling
+ * cards disagree about which to call: kimi-code and claude call it \`/models\`,
+ * workbuddy and command-code call it \`/settings\`. Serving both costs one string
+ * comparison and removes a client-side special case.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { MINIMAX_CODE_PROVIDER_ID, type MinimaxCodeWebStatus } from '../../shared/minimax-code-contracts.ts';
+import { type MinimaxCodeAccountPool } from './account-pool.ts';
+import { MinimaxCodeCredentialStore, MinimaxCodeModelSettingsStore, type MinimaxCodeModelSettings, type MinimaxCodePreferenceStore, type MinimaxCodeSettingsPatch } from './token-store.ts';
+import { ensureAccessToken, getWebLogin } from './oauth.ts';
+/** The sub-path one request addresses, whichever prefix it arrived under. */
+export declare function subPathOf(requestUrl: string): string;
+/**
+ * The stored selection, however this deployment persists it.
+ *
+ * The routes accept either shape so a composition that still has the register
+ * settings seam and one that only has the file both work: the caller passes
+ * whichever it wired, and nothing in this file needs to know which it got. The
+ * patch type is the store's own, deliberately, so a field added to the settings
+ * document cannot become one this route accepts but the stores silently drop.
+ */
+export interface MinimaxCodeSettingsSource {
+    /** Current selection: a value on the register seam, a read on the file store. */
+    status(): Promise<MinimaxCodeModelSettings> | MinimaxCodeModelSettings;
+    update(patch: MinimaxCodeSettingsPatch): Promise<MinimaxCodeModelSettings>;
+}
+export interface MinimaxCodeStatusOptions {
+    fetchFn?: typeof fetch;
+    /** Whether this plugin currently owns the provider route; re-read on every status. */
+    serving?: boolean | (() => boolean);
+    /** Diagnostic when another plugin owns the provider route; re-read on every status. */
+    conflict?: string | null | (() => string | null);
+    /**
+     * Where the model selection lives.
+     *
+     * Omitted, the routes read the default settings file, which is what a caller
+     * that only wants the connection half of the card gets. The plugin entry
+     * supplies the same store the adapter was built with, so the card and the
+     * request path can never read two different selections.
+     */
+    settings?: MinimaxCodeSettingsSource;
+    /**
+     * The account pool, when this process installed one.
+     *
+     * Omitting it is a supported posture: the line then behaves as the
+     * single-credential route it was before the pool existed, and the status
+     * reports `poolInstalled: false` so the card can say so rather than render an
+     * empty account list that looks like a bug.
+     */
+    accountPool?: MinimaxCodeAccountPool;
+}
+/** Everything the settings card renders. */
+export declare function getMinimaxCodeWebStatus(store: MinimaxCodeCredentialStore, options?: MinimaxCodeStatusOptions, settingsSource?: MinimaxCodeSettingsSource): Promise<MinimaxCodeWebStatus>;
+export declare function registerMinimaxCodeRoutes(ctx: Context, store?: MinimaxCodeCredentialStore, options?: MinimaxCodeStatusOptions, modelSettings?: MinimaxCodeModelSettingsStore, preferences?: MinimaxCodePreferenceStore): () => void;
+/** Test seam: forget which sign-in the status route reports. */
+export declare function resetLatestLogin(): void;
+export { MINIMAX_CODE_PROVIDER_ID, getWebLogin, ensureAccessToken };
+//# sourceMappingURL=routes.d.ts.map

package/lib/types/host/minimax-code/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EACL,wBAAwB,EAMxB,KAAK,oBAAoB,EAC1B,MAAM,wCAAwC,CAAA;AAG/C,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAE7B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC9B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,iBAAiB,EACjB,WAAW,EAKZ,MAAM,YAAY,CAAA;AAqDnB,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,yBAAyB;IACxC,iFAAiF;IACjF,MAAM,IAAI,OAAO,CAAC,wBAAwB,CAAC,GAAG,wBAAwB,CAAA;IACtE,MAAM,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAA;CAC3E;AAuBD,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,sFAAsF;IACtF,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,CAAA;IACnC,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC,CAAA;IAChD;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,yBAAyB,CAAA;IACpC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,sBAAsB,CAAA;CACrC;AAOD,4CAA4C;AAC5C,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE,wBAA6B,EACtC,cAAc,CAAC,EAAE,yBAAyB,GACzC,OAAO,CAAC,oBAAoB,CAAC,CA8D/B;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,EACZ,KAAK,GAAE,0BAA6D,EACpE,OAAO,GAAE,wBAA6B,EACtC,aAAa,GAAE,6BAAmE,EAClF,WAAW,CAAC,EAAE,0BAA0B,GACvC,MAAM,IAAI,CAyOZ;AAED,gEAAgE;AAChE,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAA"}