@redonvn/event-ws-cliproxyapi-sdk 1.0.4 → 1.0.6

package/dist/client.d.ts

@@ -0,0 +1,19 @@
+import type { HTTPRequest, ProviderEvent, ProviderOptions, WSRequestContext } from './types.js';
+export interface ProviderHandlers {
+    onRequest: (req: HTTPRequest, ctx: WSRequestContext) => void | Promise<void>;
+    onEvent?: (ev: ProviderEvent) => void;
+}
+export declare class CliproxyWSProvider {
+    private ws?;
+    private options;
+    private handlers?;
+    constructor(options: ProviderOptions);
+    connect(handlers: ProviderHandlers): Promise<void>;
+    close(): void;
+    private handleMessage;
+    private handleClose;
+    private buildContext;
+    private sendMessage;
+}
+export declare class CliproxyWSClient extends CliproxyWSProvider {
+}

package/dist/client.js

@@ -0,0 +1,96 @@
+import WebSocket from 'ws';
+import { decodeRequest, encodeChunk, encodeError, encodeResponse } from './codec.js';
+export class CliproxyWSProvider {
+    constructor(options) {
+        this.options = options;
+    }
+    connect(handlers) {
+        this.handlers = handlers;
+        if (this.ws && this.ws.readyState === WebSocket.OPEN)
+            return Promise.resolve();
+        const base = this.options.baseUrl.replace(/\/+$/, '');
+        const url = `${base.replace(/^http/, 'ws')}/v1/ws`;
+        const headers = {};
+        if (this.options.accessKey)
+            headers['Authorization'] = `Bearer ${this.options.accessKey}`;
+        this.ws = new WebSocket(url, { headers });
+        return new Promise((resolve, reject) => {
+            const ws = this.ws;
+            const onOpen = () => {
+                this.handlers?.onEvent?.({ type: 'ws:open' });
+                resolve();
+            };
+            const onErr = (err) => reject(err);
+            ws.once('open', onOpen);
+            ws.once('error', onErr);
+            ws.on('message', (raw) => this.handleMessage(raw.toString()));
+            ws.on('close', (code, reason) => this.handleClose(code, reason.toString()));
+        });
+    }
+    close() {
+        this.ws?.close();
+    }
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (!msg || !msg.id || !msg.type)
+            return;
+        if (msg.type === 'ping') {
+            this.sendMessage('pong', msg.id);
+            return;
+        }
+        if (msg.type !== 'http_request')
+            return;
+        const req = decodeRequest(msg.payload);
+        const ctx = this.buildContext(msg.id);
+        this.handlers?.onEvent?.({ type: 'request', requestId: msg.id, request: req });
+        try {
+            const result = this.handlers?.onRequest(req, ctx);
+            if (result && typeof result.then === 'function') {
+                result.catch((err) => {
+                    ctx.error(err?.message ?? 'provider error');
+                });
+            }
+        }
+        catch (err) {
+            ctx.error(err instanceof Error ? err.message : 'provider error');
+        }
+    }
+    handleClose(code, reason) {
+        this.handlers?.onEvent?.({ type: 'ws:close', code, reason });
+    }
+    buildContext(requestId) {
+        return {
+            requestId,
+            respond: (resp) => {
+                this.sendMessage('http_response', requestId, encodeResponse(resp));
+            },
+            streamStart: (status, headers) => {
+                const payload = encodeResponse({ status: status ?? 200, headers, body: '' });
+                this.sendMessage('stream_start', requestId, payload);
+            },
+            streamChunk: (chunk) => {
+                this.sendMessage('stream_chunk', requestId, encodeChunk(chunk));
+            },
+            streamEnd: () => {
+                this.sendMessage('stream_end', requestId);
+            },
+            error: (message, status) => {
+                this.sendMessage('error', requestId, encodeError(message, status));
+            }
+        };
+    }
+    sendMessage(type, id, payload) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const msg = (payload === undefined ? { id, type } : { id, type, payload });
+        this.ws.send(JSON.stringify(msg));
+    }
+}
+export class CliproxyWSClient extends CliproxyWSProvider {
+}

package/dist/codec.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPRequest, HTTPResponse, WSErrorPayload, WSHttpRequestPayload, WSHttpResponsePayload, WSStreamChunkPayload } from './types.js';
+export declare function decodeRequest(payload?: WSHttpRequestPayload): HTTPRequest;
+export declare function encodeResponse(resp: HTTPResponse): WSHttpResponsePayload;
+export declare function decodeResponse(payload?: WSHttpResponsePayload): HTTPResponse;
+export declare function encodeChunk(chunk: string): WSStreamChunkPayload;
+export declare function decodeChunk(payload?: WSStreamChunkPayload): string;
+export declare function encodeError(message: string, status?: number): WSErrorPayload;
+export declare function decodeError(payload?: WSErrorPayload): string;

package/dist/codec.js

@@ -0,0 +1,79 @@
+export function decodeRequest(payload) {
+    const method = typeof payload?.method === 'string' ? payload.method : 'GET';
+    const url = typeof payload?.url === 'string' ? payload.url : '';
+    const rawHeaders = payload?.headers;
+    const headers = {};
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = [raw];
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    const sent_at = typeof payload?.sent_at === 'string' ? payload.sent_at : undefined;
+    return { method, url, headers, body, sent_at };
+}
+export function encodeResponse(resp) {
+    const headers = {};
+    if (resp.headers) {
+        for (const [key, value] of Object.entries(resp.headers)) {
+            if (Array.isArray(value))
+                headers[key] = value.map(String);
+            else
+                headers[key] = [String(value)];
+        }
+    }
+    return {
+        status: resp.status ?? 200,
+        headers,
+        body: resp.body ?? ''
+    };
+}
+export function decodeResponse(payload) {
+    const status = typeof payload?.status === 'number'
+        ? payload.status
+        : typeof payload?.status === 'string'
+            ? Number(payload.status)
+            : 200;
+    const headers = {};
+    const rawHeaders = payload?.headers;
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = raw;
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    return { status, headers, body };
+}
+export function encodeChunk(chunk) {
+    return { data: chunk ?? '' };
+}
+export function decodeChunk(payload) {
+    const data = payload?.data;
+    return typeof data === 'string' ? data : '';
+}
+export function encodeError(message, status) {
+    const payload = { error: message || 'wsrelay: upstream error' };
+    if (typeof status === 'number' && !Number.isNaN(status)) {
+        payload.status = status;
+    }
+    return payload;
+}
+export function decodeError(payload) {
+    const message = typeof payload?.error === 'string' ? payload.error : 'wsrelay: upstream error';
+    const status = typeof payload?.status === 'number'
+        ? payload.status
+        : typeof payload?.status === 'string'
+            ? Number(payload.status)
+            : 0;
+    return status ? `${message} (status=${status})` : message;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAIErrorResponse, ErrorResponse, StatusResponse, JsonObject } from '../http/types.js';
+export type ManagementErrorResponse = ErrorResponse;
+export type ApiErrorPayload = OpenAIErrorResponse | ManagementErrorResponse | StatusResponse | JsonObject | {
+    error: string;
+};
+export declare class APIError extends Error {
+    readonly status: number;
+    readonly payload?: ApiErrorPayload;
+    constructor(message: string, status: number, payload?: ApiErrorPayload);
+}
+export declare function isOpenAIError(payload: unknown): payload is OpenAIErrorResponse;
+export declare function isStatusError(payload: unknown): payload is StatusResponse;
+export declare function isManagementError(payload: unknown): payload is ManagementErrorResponse;

package/dist/errors/index.js

@@ -0,0 +1,26 @@
+export class APIError extends Error {
+    constructor(message, status, payload) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+        this.payload = payload;
+    }
+}
+export function isOpenAIError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return !!obj.error && typeof obj.error.message === 'string' && typeof obj.error.type === 'string';
+}
+export function isStatusError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.status === 'string' && (obj.status === 'error' || obj.status === 'wait' || obj.status === 'ok');
+}
+export function isManagementError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.error === 'string';
+}

package/dist/http/client.d.ts

@@ -0,0 +1,260 @@
+import type { AmpModelMapping, AmpModelMappingsPatch, AmpUpstreamAPIKeyEntry, AmpUpstreamAPIKeysPatch, ApiCallRequest, ApiCallResponse, AuthFileDeleteResponse, AuthFileListQuery, AuthFileListResponse, AuthFileModelsQuery, AuthFileModelsResponse, AuthFileStatusRequest, AuthFileStatusResponse, AuthStatusResponse, ClaudeKey, ClaudeKeyPatch, ClaudeMessagesRequest, CliproxyAuthsQuery, CliproxyAuthsResponse, CliproxyChatRequest, CliproxyModelsQuery, CliproxyModelsResponse, CodexKey, CodexKeyPatch, Config, DeleteLogsResponse, ErrorLogFilesResponse, GeminiCompatibleRequest, GeminiGenerateContentRequest, GeminiKey, GeminiKeyPatch, KeepAliveResponse, KeyedValueResponse, LogLinesResponse, ModelListResponse, OAuthCallbackRequest, OAuthCallbackResponse, OAuthExcludedModelsPatch, OAuthModelAlias, OAuthModelAliasPatch, OAuthStartResponse, OpenAIChatCompletionRequest, OpenAICompatibility, OpenAICompatPatch, OpenAICompletionRequest, OpenAIResponsesRequest, PatchByIndexOrMatch, PatchStringListRequest, RootResponse, UsageExportResponse, UsageGetResponse, UsageImportRequest, UsageImportResponse, VertexCompatKey, VertexCompatPatch } from './types.js';
+export interface HttpClientOptions {
+    baseUrl: string;
+    accessKey?: string;
+    managementKey?: string;
+    localPassword?: string;
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+}
+export declare class CliproxyApiClient {
+    readonly baseUrl: string;
+    private accessKey?;
+    private managementKey?;
+    private localPassword?;
+    private fetchImpl;
+    constructor(options: HttpClientOptions);
+    setAccessKey(key?: string): void;
+    setManagementKey(key?: string): void;
+    setLocalPassword(value?: string): void;
+    private buildUrl;
+    private requestJson;
+    private requestText;
+    private requestRaw;
+    private applyAuth;
+    private throwApiError;
+    getWebsocketUrl(path?: string): string;
+    getRoot(): Promise<RootResponse>;
+    getManagementHtml(): Promise<Response>;
+    keepAlive(): Promise<KeepAliveResponse>;
+    anthropicCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    codexCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    googleCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    iflowCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    antigravityCallback(query: {
+        code?: string;
+        state?: string;
+        error?: string;
+        error_description?: string;
+    }): Promise<Response>;
+    postV1Internal(method: string, body: GeminiGenerateContentRequest, options?: RequestOptions): Promise<Response>;
+    getModels(): Promise<ModelListResponse>;
+    postChatCompletions(body: OpenAIChatCompletionRequest, options?: RequestOptions): Promise<Response>;
+    postCompletions(body: OpenAICompletionRequest, options?: RequestOptions): Promise<Response>;
+    postMessages(body: ClaudeMessagesRequest, options?: RequestOptions): Promise<Response>;
+    postMessagesCountTokens(body: ClaudeMessagesRequest, options?: RequestOptions): Promise<Response>;
+    postResponses(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+    postResponsesCompact(body: OpenAIResponsesRequest, options?: RequestOptions): Promise<Response>;
+    getCliproxyAuths(query?: CliproxyAuthsQuery): Promise<CliproxyAuthsResponse>;
+    getCliproxyModels(query?: CliproxyModelsQuery): Promise<CliproxyModelsResponse>;
+    postCliproxyChat(body: CliproxyChatRequest, options?: RequestOptions): Promise<Response>;
+    getGeminiModels(options?: RequestOptions): Promise<Response>;
+    postGeminiModelsAction(action: string, body: GeminiCompatibleRequest, options?: RequestOptions): Promise<Response>;
+    getGeminiModelsAction(action: string, query?: Record<string, string | number | boolean | undefined>, options?: RequestOptions): Promise<Response>;
+    getUsage(): Promise<UsageGetResponse>;
+    exportUsage(): Promise<UsageExportResponse>;
+    importUsage(body: UsageImportRequest): Promise<UsageImportResponse>;
+    getConfig(): Promise<Config>;
+    getConfigYaml(): Promise<string>;
+    putConfigYaml(body: string): Promise<KeyedValueResponse<"status", "ok">>;
+    getLatestVersion(): Promise<KeyedValueResponse<"latest-version", string>>;
+    getDebug(): Promise<KeyedValueResponse<"debug", boolean>>;
+    putDebug(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchDebug(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getLoggingToFile(): Promise<KeyedValueResponse<"logging-to-file", boolean>>;
+    putLoggingToFile(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchLoggingToFile(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getLogsMaxTotalSizeMB(): Promise<KeyedValueResponse<"logs-max-total-size-mb", number>>;
+    putLogsMaxTotalSizeMB(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchLogsMaxTotalSizeMB(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getErrorLogsMaxFiles(): Promise<KeyedValueResponse<"error-logs-max-files", number>>;
+    putErrorLogsMaxFiles(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchErrorLogsMaxFiles(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getUsageStatisticsEnabled(): Promise<KeyedValueResponse<"usage-statistics-enabled", boolean>>;
+    putUsageStatisticsEnabled(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchUsageStatisticsEnabled(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getProxyUrl(): Promise<KeyedValueResponse<"proxy-url", string>>;
+    putProxyUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchProxyUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteProxyUrl(): Promise<KeyedValueResponse<"status", "ok">>;
+    apiCall(body: ApiCallRequest): Promise<ApiCallResponse>;
+    getSwitchProject(): Promise<KeyedValueResponse<"switch-project", boolean>>;
+    putSwitchProject(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchSwitchProject(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getSwitchPreviewModel(): Promise<KeyedValueResponse<"switch-preview-model", boolean>>;
+    putSwitchPreviewModel(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchSwitchPreviewModel(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getApiKeys(): Promise<KeyedValueResponse<"api-keys", string[]>>;
+    putApiKeys(body: string[] | {
+        items: string[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchApiKeys(body: PatchStringListRequest): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteApiKeys(query?: {
+        index?: number;
+        value?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getGeminiKeys(): Promise<KeyedValueResponse<"gemini-api-key", GeminiKey[]>>;
+    putGeminiKeys(body: GeminiKey[] | {
+        items: GeminiKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchGeminiKey(body: PatchByIndexOrMatch<GeminiKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteGeminiKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getLogs(query?: {
+        limit?: number;
+        after?: number;
+    }): Promise<LogLinesResponse>;
+    deleteLogs(): Promise<DeleteLogsResponse>;
+    getRequestErrorLogs(): Promise<ErrorLogFilesResponse>;
+    downloadRequestErrorLog(name: string): Promise<Response>;
+    getRequestLogById(id: string): Promise<Response>;
+    getRequestLog(): Promise<KeyedValueResponse<"request-log", boolean>>;
+    putRequestLog(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRequestLog(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getWebsocketAuth(): Promise<KeyedValueResponse<"ws-auth", boolean>>;
+    putWebsocketAuth(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchWebsocketAuth(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpCode(): Promise<KeyedValueResponse<"ampcode", import("./types.js").AmpCodeConfig>>;
+    getAmpUpstreamUrl(): Promise<KeyedValueResponse<"upstream-url", string>>;
+    putAmpUpstreamUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamUrl(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamUrl(): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpUpstreamApiKey(): Promise<KeyedValueResponse<"upstream-api-key", string>>;
+    putAmpUpstreamApiKey(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamApiKey(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamApiKey(): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpRestrictManagementToLocalhost(): Promise<KeyedValueResponse<"restrict-management-to-localhost", boolean>>;
+    putAmpRestrictManagementToLocalhost(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpRestrictManagementToLocalhost(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpModelMappings(): Promise<KeyedValueResponse<"model-mappings", AmpModelMapping[]>>;
+    putAmpModelMappings(body: AmpModelMapping[] | AmpModelMappingsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpModelMappings(body: AmpModelMappingsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpModelMappings(query?: {
+        index?: number;
+        match?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpForceModelMappings(): Promise<KeyedValueResponse<"force-model-mappings", boolean>>;
+    putAmpForceModelMappings(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpForceModelMappings(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getAmpUpstreamApiKeys(): Promise<KeyedValueResponse<"upstream-api-keys", AmpUpstreamAPIKeyEntry[]>>;
+    putAmpUpstreamApiKeys(body: AmpUpstreamAPIKeyEntry[] | AmpUpstreamAPIKeysPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    patchAmpUpstreamApiKeys(body: AmpUpstreamAPIKeysPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteAmpUpstreamApiKeys(query?: {
+        index?: number;
+        match?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getRequestRetry(): Promise<KeyedValueResponse<"request-retry", number>>;
+    putRequestRetry(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRequestRetry(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getMaxRetryInterval(): Promise<KeyedValueResponse<"max-retry-interval", number>>;
+    putMaxRetryInterval(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchMaxRetryInterval(body: KeyedValueResponse<'value', number>): Promise<KeyedValueResponse<"status", "ok">>;
+    getForceModelPrefix(): Promise<KeyedValueResponse<"force-model-prefix", boolean>>;
+    putForceModelPrefix(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchForceModelPrefix(body: KeyedValueResponse<'value', boolean>): Promise<KeyedValueResponse<"status", "ok">>;
+    getRoutingStrategy(): Promise<KeyedValueResponse<"strategy", string>>;
+    putRoutingStrategy(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    patchRoutingStrategy(body: KeyedValueResponse<'value', string>): Promise<KeyedValueResponse<"status", "ok">>;
+    getClaudeKeys(): Promise<KeyedValueResponse<"claude-api-key", ClaudeKey[]>>;
+    putClaudeKeys(body: ClaudeKey[] | {
+        items: ClaudeKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchClaudeKey(body: PatchByIndexOrMatch<ClaudeKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteClaudeKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getCodexKeys(): Promise<KeyedValueResponse<"codex-api-key", CodexKey[]>>;
+    putCodexKeys(body: CodexKey[] | {
+        items: CodexKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchCodexKey(body: PatchByIndexOrMatch<CodexKeyPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteCodexKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOpenAICompatibility(): Promise<KeyedValueResponse<"openai-compatibility", OpenAICompatibility[]>>;
+    putOpenAICompatibility(body: OpenAICompatibility[] | {
+        items: OpenAICompatibility[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOpenAICompatibility(body: PatchByIndexOrMatch<OpenAICompatPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOpenAICompatibility(query?: {
+        name?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getVertexCompatKeys(): Promise<KeyedValueResponse<"vertex-api-key", VertexCompatKey[]>>;
+    putVertexCompatKeys(body: VertexCompatKey[] | {
+        items: VertexCompatKey[];
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchVertexCompatKey(body: PatchByIndexOrMatch<VertexCompatPatch>): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteVertexCompatKey(query?: {
+        'api-key'?: string;
+        index?: number;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOAuthExcludedModels(): Promise<KeyedValueResponse<"oauth-excluded-models", Record<string, string[]>>>;
+    putOAuthExcludedModels(body: Record<string, string[]> | {
+        items: Record<string, string[]>;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOAuthExcludedModels(body: OAuthExcludedModelsPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOAuthExcludedModels(query?: {
+        provider?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    getOAuthModelAlias(): Promise<KeyedValueResponse<"oauth-model-alias", Record<string, OAuthModelAlias[]>>>;
+    putOAuthModelAlias(body: Record<string, OAuthModelAlias[]> | {
+        items: Record<string, OAuthModelAlias[]>;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    patchOAuthModelAlias(body: PatchByIndexOrMatch<OAuthModelAliasPatch> | OAuthModelAliasPatch): Promise<KeyedValueResponse<"status", "ok">>;
+    deleteOAuthModelAlias(query?: {
+        provider?: string;
+        channel?: string;
+    }): Promise<KeyedValueResponse<"status", "ok">>;
+    listAuthFiles(query?: AuthFileListQuery): Promise<AuthFileListResponse>;
+    getAuthFileModels(query: AuthFileModelsQuery): Promise<AuthFileModelsResponse>;
+    getStaticModelDefinitions(channel: string): Promise<Response>;
+    downloadAuthFile(query: {
+        name: string;
+    }): Promise<Response>;
+    uploadAuthFile(file: Blob, name?: string): Promise<Response>;
+    deleteAuthFile(query: {
+        name: string;
+    }): Promise<AuthFileDeleteResponse>;
+    patchAuthFileStatus(body: AuthFileStatusRequest): Promise<AuthFileStatusResponse>;
+    importVertexCredential(file: Blob): Promise<Response>;
+    requestAnthropicAuthUrl(): Promise<OAuthStartResponse>;
+    requestCodexAuthUrl(): Promise<OAuthStartResponse>;
+    requestGeminiCliAuthUrl(): Promise<OAuthStartResponse>;
+    requestAntigravityAuthUrl(): Promise<OAuthStartResponse>;
+    requestQwenAuthUrl(): Promise<OAuthStartResponse>;
+    requestKimiAuthUrl(): Promise<OAuthStartResponse>;
+    requestIFlowAuthUrl(): Promise<OAuthStartResponse>;
+    requestIFlowCookieToken(body: KeyedValueResponse<'cookie', string>): Promise<OAuthStartResponse>;
+    postOAuthCallback(body: OAuthCallbackRequest): Promise<OAuthCallbackResponse>;
+    getAuthStatus(query?: {
+        state?: string;
+    }): Promise<AuthStatusResponse>;
+}