@vibedev-si/dsh-vibedev 0.2.1

package/lib/auth/credentials.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Which VibeDev credential a gateway request carries, in order: the host's
+ * signed-in VibeDev account (the VibeDev app's account service hands out its
+ * token for the gateway origin), the plugin's own sign-in, then a development
+ * key named by an environment variable.
+ * @module dsh-vibedev/auth/credentials
+ */
+import type { CredentialProvider } from '@deepseek-ai/dsh-credentials';
+import type { DeepSeekAccount } from '@deepseek-ai/dsh-deepseek-account';
+import type { GatewayCredential } from '../gateway/http.js';
+import type { GrantStorage, PluginLogin } from './login.js';
+/** Where a credential came from, for status lines. */
+export type CredentialSource = GatewayCredential['kind'];
+/** Construction options. */
+export interface CredentialChainOptions {
+    /** Gateway origin; the host account is asked for a token for this origin. */
+    readonly origin: string;
+    /** The host's account service, when one is loaded. */
+    readonly account: () => DeepSeekAccount | undefined;
+    readonly plugin?: PluginLogin;
+    /** The development key, when configured. */
+    readonly apiKey: () => string | undefined;
+}
+/** Resolves the credential for each request and routes rejections back to its owner. */
+export declare class CredentialChain {
+    private readonly options;
+    /**
+     * @param options - origin and the three sources.
+     */
+    constructor(options: CredentialChainOptions);
+    /** The credential for the next request, or undefined while nobody is signed in. */
+    resolve(): Promise<GatewayCredential | undefined>;
+    /**
+     * The gateway rejected a credential: let its owner refresh it.
+     * @param credential - the rejected credential.
+     */
+    reject(credential: GatewayCredential): Promise<void>;
+}
+/**
+ * Grant storage: the host's credential store when one is loaded (a grant
+ * record the store keeps verbatim), else a private file in the state
+ * directory. The device id is not a secret and lives in the state directory.
+ * @param stateDir - the plugin state directory.
+ * @param credentials - the host's credential store, when loaded.
+ * @returns the storage.
+ */
+export declare function grantStorage(stateDir: string, credentials: () => CredentialProvider | undefined): GrantStorage;

package/lib/auth/login.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The plugin's own VibeDev sign-in, for hosts whose account service does not
+ * hold a VibeDev session (official DeepSeek Harness). Authorization code with
+ * PKCE (S256) through the system browser and a loopback callback on
+ * 127.0.0.1; the gateway issues a plugin session (`client=vibedev-plugin`)
+ * whose access token is refreshed with a rotating refresh token.
+ *
+ * Contract (gateway vibedev204):
+ * - browser: `{origin}/vibedev-link?callback=http://127.0.0.1:<port>/<path>&state&response_type=code&code_challenge&code_challenge_method=S256&client=vibedev-plugin`
+ * - `POST /api/v1/vibedev/link/redeem {code, code_verifier, token_type:'app', client, device_id, device_model, os_version}`
+ * - `POST /api/v1/vibedev/app-token/refresh {refresh_token, device_id}`: a new pair every time; the old refresh token dies
+ * - `POST /api/v1/vibedev/app-token/revoke` (bearer or `{refresh_token}`): always 204
+ * @module dsh-vibedev/auth/login
+ */
+/** A stored plugin session. */
+export interface PluginGrant {
+    readonly accessToken: string;
+    readonly refreshToken: string;
+    /** Epoch ms. */
+    readonly expiresAt: number;
+    readonly refreshExpiresAt: number;
+    readonly sessionId?: string;
+    readonly user?: {
+        readonly id?: string;
+        readonly email?: string;
+        readonly nickname?: string;
+    };
+}
+/** What a read-modify-write of the stored grant does. */
+export type GrantChange = {
+    readonly kind: 'keep';
+} | {
+    readonly kind: 'set';
+    readonly grant: PluginGrant;
+} | {
+    readonly kind: 'delete';
+};
+/** Where the grant and the device id live. */
+export interface GrantStorage {
+    read(): Promise<PluginGrant | undefined>;
+    write(grant: PluginGrant | undefined): Promise<void>;
+    /**
+     * Read-modify-write of the stored grant, one at a time across processes
+     * where the store supports it, so two processes never spend one refresh token.
+     * @param change - decides the change from the grant as stored now.
+     */
+    update(change: (current: PluginGrant | undefined) => Promise<GrantChange>): Promise<void>;
+    /** A stable id for this installation, sent on redeem and on every refresh. */
+    deviceId(): Promise<string>;
+}
+/** Construction options; `fetch`, the clock and `openBrowser` are test seams. */
+export interface PluginLoginOptions {
+    readonly origin: string;
+    readonly storage: GrantStorage;
+    readonly userAgent: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly now?: () => number;
+    /** Open a URL in the system browser; resolves whether that was attempted successfully. */
+    readonly openBrowser?: (url: string) => Promise<boolean>;
+    /** How long a started sign-in waits for the browser. Defaults to 5 minutes. */
+    readonly signInTimeoutMs?: number;
+    /** The client name the gateway records for the sign-in (it picks the key the usage is billed to). Defaults to `vibedev-plugin`. */
+    readonly client?: string;
+    readonly log?: (message: string) => void;
+}
+/** A sign-in waiting for the browser. */
+export interface PendingSignIn {
+    readonly url: string;
+    readonly expiresAt: number;
+    /** Settles when the sign-in completes, fails or times out. */
+    readonly done: Promise<PluginGrant>;
+}
+/**
+ * Read a token answer (`redeem` or `refresh`).
+ * @param body - the parsed envelope `{code, data}` or a bare data object.
+ * @param now - current epoch ms.
+ * @param previous - the grant being refreshed, whose identity carries over.
+ * @returns the grant, or undefined when the answer lacks tokens.
+ */
+export declare function parseGrant(body: unknown, now: number, previous?: PluginGrant): PluginGrant | undefined;
+/**
+ * Open a URL in the system browser without a shell (an `&` in the URL must not split a command line).
+ * @param url - the URL.
+ * @returns whether the opener started.
+ */
+export declare function openInBrowser(url: string): Promise<boolean>;
+/** The plugin's VibeDev session. */
+export declare class PluginLogin {
+    private readonly options;
+    private grant;
+    private loaded;
+    private refreshing;
+    private pending;
+    private readonly listeners;
+    private readonly now;
+    private readonly origin;
+    /**
+     * @param options - gateway origin, storage and test seams.
+     */
+    constructor(options: PluginLoginOptions);
+    private load;
+    /** Take a grant as current and tell listeners when it changed. */
+    private adopt;
+    private save;
+    /**
+     * Hear about sign-in and sign-out.
+     * @param listener - called after every change.
+     * @returns unsubscribe.
+     */
+    onChange(listener: () => void): () => void;
+    /** The signed-in user, or undefined while signed out. */
+    user(): Promise<PluginGrant['user'] | undefined>;
+    /** Whether a sign-in is waiting for the browser, and its link. */
+    pendingSignIn(): {
+        url: string;
+        expiresAt: number;
+    } | undefined;
+    /**
+     * The access token for the next request, refreshed when it is about to expire.
+     * @returns the token, or undefined while signed out.
+     */
+    token(): Promise<string | undefined>;
+    /**
+     * The gateway rejected a token (401): refresh once, unless it already changed.
+     * @param token - the rejected token.
+     */
+    reject(token: string): Promise<void>;
+    /**
+     * Refresh one grant; concurrent callers share the request. The refresh runs
+     * inside the store's read-modify-write: when another process has already
+     * rotated the token, its grant is adopted instead of spending the old refresh
+     * token, which the gateway would treat as reuse and revoke the session.
+     * A rejected refresh signs out.
+     */
+    private refresh;
+    private post;
+    /**
+     * Start a sign-in: listen on a loopback port, open the authorization page in
+     * the system browser, and finish in the background when the browser returns.
+     * Starting again while one is waiting returns the waiting one.
+     * @param request - `open: false` leaves opening the link to the caller (a page that opens it itself).
+     * @returns the authorization link, whether a browser was opened, and the completion.
+     */
+    startSignIn(request?: {
+        open?: boolean;
+    }): Promise<PendingSignIn & {
+        opened: boolean;
+    }>;
+    private redeem;
+    /** Sign out: revoke the session at the gateway (best effort) and forget it. */
+    signOut(): Promise<void>;
+    /** Stop a waiting sign-in. */
+    dispose(): void;
+}

package/lib/gateway/assets.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The gateway media library (`/v1/media-assets`): every reference a video
+ * request carries is uploaded here first, so the gateway can check its type and
+ * measure its length, and the provider fetches it from the gateway instead of
+ * an arbitrary link.
+ *
+ * Flow: `POST /uploads` (deduplicated by content digest), `PUT upload_url` with
+ * the returned upload headers when an upload is needed, `POST /{id}/complete`.
+ * An asset the library already holds is read back through `/refresh`, which
+ * also carries its measured duration.
+ * @module dsh-vibedev/gateway/assets
+ */
+import type { GatewayHttp } from './http.js';
+import type { LoadedMedia } from '../media/sources.js';
+/** A media library asset a request can reference. */
+export interface UploadedAsset {
+    readonly assetId: string;
+    /** The URL to put in a generation request. */
+    readonly referenceUrl: string;
+    readonly contentUrl?: string;
+    readonly contentType: string;
+    readonly expiresAt?: string;
+    /** Measured length of an audio or video, in milliseconds. */
+    readonly durationMs?: number;
+    readonly sha256: string;
+    readonly bytes: number;
+}
+/** Purposes the plugin uploads under. */
+export type AssetPurpose = 'video_reference';
+/**
+ * Read an asset answer from `uploads`, `complete` or `refresh`.
+ * @param body - the parsed answer.
+ * @param fallbackType - the type the upload declared.
+ * @returns the asset facts, or undefined when the answer names no usable URL.
+ */
+export declare function parseAsset(body: unknown, fallbackType: string): Omit<UploadedAsset, 'sha256' | 'bytes'> | undefined;
+/** Uploads references and remembers them for the life of the plugin. */
+export declare class MediaLibrary {
+    private readonly http;
+    private readonly now;
+    private readonly cache;
+    /**
+     * @param http - the gateway client.
+     * @param now - clock, for expiry checks.
+     */
+    constructor(http: GatewayHttp, now?: () => number);
+    /** Forget every remembered asset, as after an account change: assets belong to the account that uploaded them. */
+    clear(): void;
+    /**
+     * Upload one loaded input, or reuse the asset the library already holds.
+     * @param media - the loaded input.
+     * @param purpose - the asset purpose.
+     * @param signal - cancels the upload.
+     * @returns the asset.
+     */
+    upload(media: LoadedMedia, purpose: AssetPurpose, signal?: AbortSignal): Promise<UploadedAsset>;
+    private expiring;
+    private remember;
+    private refresh;
+    private read;
+}

package/lib/gateway/catalog.d.ts

@@ -0,0 +1,126 @@
+/**
+ * The media models of the VibeDev gateway catalog (`GET /v1/models`): image,
+ * video, music/podcast and transcription models, with each model's declared
+ * capabilities and price. Chat models and models the client drives itself
+ * (`internal_role`) are left out.
+ *
+ * Video capabilities follow the gateway's `video` block: model-level limits plus
+ * the versioned per-mode declarations (`modes_schema_version: 1`). A mode the
+ * model does not list is unsupported; an unknown schema version makes the model
+ * unusable rather than guessed at.
+ * @module dsh-vibedev/gateway/catalog
+ */
+/** What a media model produces. */
+export type MediaKind = 'image' | 'video' | 'audio' | 'transcription';
+/** The video generation modes of catalog schema v1, under their wire names. */
+export declare const VIDEO_MODES: readonly ["text_to_video", "first_frame", "first_last_frame", "omni_reference"];
+export type VideoMode = typeof VIDEO_MODES[number];
+/** The inputs a video request can carry, under the gateway's request field names. */
+export declare const VIDEO_INPUTS: readonly ["firstFrame", "lastFrame", "referenceImages", "referenceVideos", "referenceAudios"];
+export type VideoInput = typeof VIDEO_INPUTS[number];
+/** How many of one input a mode accepts, and whether it must be a gateway-hosted asset. */
+export interface VideoInputLimit {
+    readonly min: number;
+    readonly max: number;
+    /** The input must be uploaded to the gateway media library first. */
+    readonly hosted: boolean;
+}
+/** One mode's declaration. Lists that are absent inherit the model-level lists. */
+export interface VideoModeConstraint {
+    readonly inputs: Partial<Record<VideoInput, VideoInputLimit>>;
+    /** At least one group must be fully present (each input at least once). Empty: no requirement. */
+    readonly requiredAnyOf: readonly (readonly VideoInput[])[];
+    readonly ratios?: readonly string[];
+    readonly resolutions?: readonly string[];
+    readonly durations?: readonly number[];
+}
+/** One allowed duration/ratio/resolution combination. */
+export interface VideoCombination {
+    readonly duration?: number;
+    readonly ratio?: string;
+    readonly resolution?: string;
+}
+/** A video model's declared capabilities. */
+export interface VideoCapabilities {
+    /**
+     * Per-mode declarations. `undefined` for a legacy entry without modes, whose
+     * modes are derived from the model-level fields by {@link effectiveVideoModes}.
+     */
+    readonly modes?: Partial<Record<VideoMode, VideoModeConstraint>>;
+    /** A modes block was present but its schema version is not one this plugin reads. */
+    readonly unreadableModesVersion?: number;
+    readonly ratios?: readonly string[];
+    readonly resolutions?: readonly string[];
+    readonly durations?: readonly number[];
+    readonly combinations?: readonly VideoCombination[];
+    readonly nativeAudio?: boolean;
+    readonly textToVideo?: boolean;
+    readonly imageToVideo?: boolean;
+    readonly firstFrame?: boolean;
+    readonly lastFrame?: boolean;
+    readonly maxReferenceImages?: number;
+    readonly maxReferenceVideos?: number;
+    readonly maxReferenceAudios?: number;
+    readonly allowedImageMimes?: readonly string[];
+    readonly allowedVideoMimes?: readonly string[];
+    readonly allowedAudioMimes?: readonly string[];
+    readonly maxReferenceImageBytes?: number;
+    readonly maxReferenceVideoBytes?: number;
+    readonly maxReferenceAudioBytes?: number;
+    readonly maxAssetBytes?: number;
+    readonly minReferenceVideoSeconds?: number;
+    readonly maxReferenceVideoSeconds?: number;
+    readonly maxTotalReferenceVideoSeconds?: number;
+    /** References must be relayed through the gateway media library. */
+    readonly gatewayRelayRequired?: boolean;
+}
+/** One price tier: video tiers are resolutions (`720p`), image tiers size buckets (`1K`). */
+export interface MediaPriceTier {
+    readonly tier: string;
+    readonly unit: 'generation' | 'second';
+    readonly amount: number;
+}
+/** A model's selling price, account multiplier included. */
+export interface MediaPricing {
+    readonly currency: string;
+    readonly tiers: readonly MediaPriceTier[];
+    readonly default?: {
+        readonly unit: 'generation' | 'second';
+        readonly amount: number;
+    };
+}
+/** One media model of the catalog. */
+export interface MediaModel {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly kind: MediaKind;
+    /** For audio models: what they produce. */
+    readonly audioKind?: 'music' | 'podcast';
+    /** Endpoints the catalog lists for the model. */
+    readonly endpoints: readonly string[];
+    readonly inputModalities: readonly string[];
+    readonly pricing?: MediaPricing;
+    readonly video?: VideoCapabilities;
+}
+type Json = Record<string, unknown>;
+/**
+ * Parse a `video` capability block (or the legacy video fields inside `capabilities`).
+ * @param raw - the block.
+ * @returns the capabilities found.
+ */
+export declare function parseVideoCapabilities(raw: Json): VideoCapabilities;
+/**
+ * The modes a model can serve: its declared v1 modes, or for a legacy entry the
+ * conservative set its model-level fields imply. An unreadable modes block serves none.
+ * @param video - the model's capabilities.
+ * @returns the usable modes and their constraints.
+ */
+export declare function effectiveVideoModes(video: VideoCapabilities): Partial<Record<VideoMode, VideoModeConstraint>>;
+/**
+ * Parse a `/v1/models` body into its media models.
+ * @param body - `{data:[...]}` or a bare array.
+ * @returns the media models, in catalog order.
+ */
+export declare function parseMediaCatalog(body: unknown): MediaModel[];
+export {};

package/lib/gateway/errors.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Failures the plugin reports to the model: a gateway refusal, or a request the
+ * plugin refused before anything was sent or charged. Messages are written for
+ * the model to act on and relay to the user.
+ * @module dsh-vibedev/gateway/errors
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** Machine-readable detail carried next to the message. */
+export interface MediaErrorDetails {
+    /** HTTP status when the gateway answered. */
+    readonly status?: number;
+    /** Whether the same request may succeed later. */
+    readonly retryable?: boolean;
+    /** The request field the failure names, when the gateway says which. */
+    readonly field?: string;
+    /** Where the user tops up, on a balance refusal. */
+    readonly rechargeUrl?: string;
+    /** How long the gateway asked the client to wait. */
+    readonly retryAfterMs?: number;
+    /** The gateway was full and created nothing (a busy 429/503). */
+    readonly busy?: boolean;
+    /** On a task-limit refusal: tasks in progress and the account's limit. */
+    readonly active?: number;
+    readonly limit?: number;
+    /** On an admission balance refusal: amounts in CNY, as the gateway's two-decimal strings. */
+    readonly estimatedCny?: string;
+    readonly availableCny?: string;
+    readonly pendingCny?: string;
+}
+/**
+ * One failure, with a stable `code` to route on and a message to show. It is a
+ * harness error, so a tool failure keeps the code in the durable tool result
+ * where a client can route on it (sign-in card, top-up link).
+ */
+export declare class MediaError extends HarnessError {
+    readonly details: MediaErrorDetails;
+    /**
+     * @param message - what happened and what to do next.
+     * @param code - stable failure class, such as `INSUFFICIENT_BALANCE` or `VIDEO_MODE_UNSUPPORTED`.
+     * @param details - status, retry and field facts.
+     * @param options - the underlying cause, when there is one.
+     */
+    constructor(message: string, code: string, details?: MediaErrorDetails, options?: ErrorOptions);
+}
+/** The parts of a gateway error body the plugin reads, whatever its shape. */
+export interface GatewayFailure {
+    readonly code?: string;
+    readonly message?: string;
+    readonly field?: string;
+    readonly retryable?: boolean;
+    readonly rechargeUrl?: string;
+    readonly active?: number;
+    readonly limit?: number;
+    readonly estimatedCny?: string;
+    readonly availableCny?: string;
+    readonly pendingCny?: string;
+}
+/**
+ * Read a gateway error body. The gateway answers in several shapes: OpenAI's
+ * `{error:{code,message,type}}`, its own `{error:{code,message,retryable,field}}`,
+ * the account API's `{code,message,reason}`, and a top-level `recharge_url` on
+ * balance refusals. Media admission refusals add `active`/`limit` (task limit)
+ * or `estimated_cny`/`available_cny`/`pending_cny` (balance).
+ * @param body - the parsed JSON body, or undefined when it was not JSON.
+ * @returns the fields found.
+ */
+export declare function parseGatewayFailure(body: unknown): GatewayFailure;
+/**
+ * Milliseconds a `Retry-After` header asks for: delta seconds or an HTTP date.
+ * @param header - the header value, or null when absent.
+ * @param now - current epoch milliseconds, for an HTTP date.
+ * @returns the wait, or undefined when absent or unreadable.
+ */
+export declare function retryAfterMs(header: string | null, now?: number): number | undefined;
+/** `(CODE: message)`, for appending the gateway's own words to a message. */
+export declare function gatewayWords(failure: GatewayFailure): string;

package/lib/gateway/http.d.ts

@@ -0,0 +1,94 @@
+/**
+ * HTTP client for the VibeDev gateway. Every gateway call goes through here so
+ * authentication, refresh after a 401, balance refusals, busy back-off and
+ * idempotency are handled once.
+ *
+ * The credential is attached only to requests on the gateway origin: upload
+ * URLs and third-party links never see it.
+ * @module dsh-vibedev/gateway/http
+ */
+import { MediaError } from './errors.js';
+import type { GatewayFailure } from './errors.js';
+/** The credential one request carries. */
+export interface GatewayCredential {
+    readonly token: string;
+    /**
+     * Where it came from: the host's VibeDev account (`account`), the plugin's own
+     * sign-in (`plugin`), or a development key from the environment (`key`). Only
+     * account and plugin tokens can be refreshed after a 401.
+     */
+    readonly kind: 'account' | 'plugin' | 'key';
+}
+/** Construction options; `fetch` and `sleep` are test seams. */
+export interface GatewayHttpOptions {
+    /** Gateway origin, such as `https://vibedev.jzsaas.com`. */
+    readonly origin: string;
+    /** The credential for the next request; undefined while nobody is signed in. */
+    readonly resolveCredential: () => Promise<GatewayCredential | undefined>;
+    /** Report a token the gateway rejected, so its owner refreshes it. */
+    readonly rejectToken?: (credential: GatewayCredential) => Promise<void>;
+    /** `User-Agent` for every request. */
+    readonly userAgent: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/** One request. */
+export interface GatewayRequest {
+    readonly method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    /** JSON body; serialized with `content-type: application/json`. */
+    readonly json?: unknown;
+    /** Raw body (multipart form, bytes) when `json` is not used. */
+    readonly body?: FormData | Uint8Array | string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly signal?: AbortSignal;
+    /** Deadline for each attempt. */
+    readonly timeoutMs?: number;
+    /** Sent as `Idempotency-Key`; makes a retried submission return the original task. */
+    readonly idempotencyKey?: string;
+    /** Send without the credential (pre-signed upload URLs, public content links). */
+    readonly anonymous?: boolean;
+    /** Retries after a busy answer (429, or 503 with a busy code or `Retry-After`). Defaults to 2. */
+    readonly busyRetries?: number;
+    /** Longest single wait for a busy answer; a longer `Retry-After` fails at once. Defaults to 15 s. */
+    readonly maxBusyWaitMs?: number;
+}
+/** The message for a call made while nobody is signed in. */
+export declare const SIGN_IN_MESSAGE: string;
+/** Gateway HTTP client. */
+export declare class GatewayHttp {
+    private readonly options;
+    readonly origin: string;
+    /**
+     * @param options - origin, credential plane, user agent and test seams.
+     */
+    constructor(options: GatewayHttpOptions);
+    /** Absolute URL for a gateway path, or the URL itself when already absolute. */
+    url(path: string): string;
+    /** Whether a URL is on the gateway origin, and so may carry the credential. */
+    isGatewayUrl(url: string): boolean;
+    /**
+     * Send one request and return the successful response.
+     * @param path - gateway path, or an absolute URL.
+     * @param request - method, body, headers and retry policy.
+     * @returns the 2xx response, body unread.
+     * @throws {@link MediaError} for every refusal, with the gateway's code.
+     */
+    send(path: string, request?: GatewayRequest): Promise<Response>;
+    /**
+     * Send one request and parse its JSON body.
+     * @param path - gateway path, or an absolute URL.
+     * @param request - method, body, headers and retry policy.
+     * @returns the parsed body.
+     */
+    json<T = unknown>(path: string, request?: GatewayRequest): Promise<T>;
+    private credential;
+    private attempt;
+}
+/**
+ * The error for an answer the client does not retry, worded for the model.
+ * @param status - HTTP status.
+ * @param failure - the parsed error body.
+ * @param wait - Retry-After in milliseconds, when given.
+ * @returns the error to throw.
+ */
+export declare function failureError(status: number, failure: GatewayFailure, wait?: number): MediaError;

package/lib/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * dsh-vibedev (formerly dsh-media): the VibeDev account and the VibeDev
+ * gateway for DeepSeek Harness — its chat models in the model pickers on their
+ * own route (`vibedev-gateway`), next to the DeepSeek account's, and image,
+ * video, music, podcast and speech-to-text tools for the agent.
+ *
+ * Everything is paid from the user's VibeDev balance: inside the VibeDev app
+ * the app's signed-in account is used; elsewhere the plugin signs in to
+ * VibeDev itself (the sidebar's "登录 VibeDev", Settings → VibeDev 账号, or the
+ * `media_account` tool). The DeepSeek account stays the Harness's own.
+ *
+ * Kept from dsh-media so an upgrade carries over: the sign-in record
+ * (`dsh-media/vibedev-session`), the data folder (`<harness home>/dsh-media`),
+ * the `vibedevMedia` host service and the media tool names.
+ *
+ * ```yaml
+ * - insert:
+ *     - id: dsh-vibedev
+ *       name: '@vibedev-si/dsh-vibedev'
+ * ```
+ * @module dsh-vibedev
+ */
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+export { MediaError } from './gateway/errors.js';
+export { MediaHostService } from './service.js';
+export type { HostTarget, MediaTaskView } from './service.js';
+export type { ImageRequest } from './tools/image.js';
+export type { VideoRequest } from './tools/video.js';
+export { parseMediaCatalog } from './gateway/catalog.js';
+export type { MediaModel, VideoCapabilities, VideoMode } from './gateway/catalog.js';
+export { ACCOUNT_ROUTE_PREFIX, AccountService } from './account/index.js';
+export type { AccountSource, AccountView } from './account/index.js';
+export { GATEWAY_SEARCH_PROVIDER_ID as SEARCH_PROVIDER_ID } from './search/provider.js';
+export { INSUFFICIENT_BALANCE_CODE, SIGN_IN_REQUIRED_CODE, VIBEDEV_ROUTE } from './llm/index.js';
+/** The package version, sent in the `User-Agent` the gateway attributes plugin traffic by. */
+export declare const version: string;
+export declare const name = "dsh-vibedev";
+export declare const inject: string[];
+export interface Config {
+    /** Name the model pickers and the Models page show for the VibeDev models. */
+    displayName: string;
+    /** VibeDev chat models listed first, in this order, when the catalog offers them. */
+    preferredModels: string[];
+    /** Open the system browser when a sign-in starts (off: the page opens the link itself). */
+    openBrowserOnSignIn: boolean;
+    /** Minutes between catalog reads while the app runs. */
+    catalogRefreshMinutes: number;
+    /** Ask the user before each paid request. */
+    confirmSpending: Volatile<boolean>;
+    /** Output folder, relative to the workspace (or absolute). */
+    outputDir: Volatile<string>;
+    /** Pinned models; empty lets the agent choose from the catalog. */
+    imageModel: Volatile<string>;
+    videoModel: Volatile<string>;
+    musicModel: Volatile<string>;
+    podcastModel: Volatile<string>;
+    transcriptionModel: Volatile<string>;
+    /** Gateway origin. */
+    gatewayOrigin: string;
+    /** Client name sent with the sign-in (`vibedev-plugin` in DeepSeek Harness; the VibeDev app sets its own). */
+    client: string;
+    /** The VibeDev account is the app's main account: its row leads the sidebar foot and Settings (the VibeDev app). */
+    primary: boolean;
+    /** Environment variable holding a development key, used only while nobody is signed in. */
+    apiKeyEnv: string;
+    /** Where tasks and the plugin's own sign-in are kept; empty for `<harness home>/dsh-media`. */
+    stateDir: string;
+}
+export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    displayName: Schema<string, string, "defined">;
+    preferredModels: Schema<string[], string[], "defined">;
+    openBrowserOnSignIn: Schema<boolean, boolean, "defined">;
+    catalogRefreshMinutes: Schema<number, number, "defined">;
+    confirmSpending: Schema<boolean, boolean, "volatile-defined">;
+    outputDir: Schema<string, string, "volatile-defined">;
+    imageModel: Schema<string, string, "volatile-defined">;
+    videoModel: Schema<string, string, "volatile-defined">;
+    musicModel: Schema<string, string, "volatile-defined">;
+    podcastModel: Schema<string, string, "volatile-defined">;
+    transcriptionModel: Schema<string, string, "volatile-defined">;
+    gatewayOrigin: Schema<string, string, "defined">;
+    client: Schema<string, string, "defined">;
+    primary: Schema<boolean, boolean, "defined">;
+    apiKeyEnv: Schema<string, string, "defined">;
+    stateDir: Schema<string, string, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    displayName: Schema<string, string, "defined">;
+    preferredModels: Schema<string[], string[], "defined">;
+    openBrowserOnSignIn: Schema<boolean, boolean, "defined">;
+    catalogRefreshMinutes: Schema<number, number, "defined">;
+    confirmSpending: Schema<boolean, boolean, "volatile-defined">;
+    outputDir: Schema<string, string, "volatile-defined">;
+    imageModel: Schema<string, string, "volatile-defined">;
+    videoModel: Schema<string, string, "volatile-defined">;
+    musicModel: Schema<string, string, "volatile-defined">;
+    podcastModel: Schema<string, string, "volatile-defined">;
+    transcriptionModel: Schema<string, string, "volatile-defined">;
+    gatewayOrigin: Schema<string, string, "defined">;
+    client: Schema<string, string, "defined">;
+    primary: Schema<boolean, boolean, "defined">;
+    apiKeyEnv: Schema<string, string, "defined">;
+    stateDir: Schema<string, string, "defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config: Config): void;