@oevortex/opencode-qwen-auth 0.1.0 → 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,445 @@
+/**
+ * Qwen OAuth and plugin types
+ * Based on revibe/core/llm/backend/qwen implementation
+ */
+interface QwenOAuthCredentials {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    expiry_date: number;
+    resource_url?: string;
+}
+interface QwenTokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    token_type: string;
+    expires_in: number;
+    error?: string;
+    error_description?: string;
+}
+interface QwenModelInfo {
+    id: string;
+    name: string;
+    context_window?: number;
+    max_output?: number;
+    input_price?: number;
+    output_price?: number;
+    supports_native_tools?: boolean;
+    supports_thinking?: boolean;
+}
+interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string;
+    reasoning_content?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+interface ToolCall {
+    id?: string;
+    index?: number;
+    type?: "function";
+    function: FunctionCall;
+}
+interface FunctionCall {
+    name?: string;
+    arguments?: string;
+}
+interface Tool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+type ToolChoice = "none" | "auto" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+};
+interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+}
+interface ChatCompletionChoice {
+    index: number;
+    message?: ChatMessage;
+    delta?: Partial<ChatMessage>;
+    finish_reason?: string | null;
+}
+interface ChatCompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens?: number;
+}
+interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage?: ChatCompletionUsage;
+    error?: {
+        message: string;
+        type?: string;
+        code?: string;
+    };
+}
+interface AuthDetails {
+    type: "oauth" | "api";
+}
+interface OAuthAuthDetails extends AuthDetails {
+    type: "oauth";
+    access?: string;
+    refresh: string;
+    expires?: number;
+}
+interface RefreshParts {
+    refreshToken: string;
+    resourceUrl?: string;
+}
+interface LoaderResult {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+interface Provider {
+    models?: Record<string, any>;
+}
+type GetAuth = () => Promise<AuthDetails>;
+interface PluginContext {
+    client: {
+        auth: {
+            set: (options: {
+                path: {
+                    id: string;
+                };
+                body: Record<string, unknown>;
+            }) => Promise<void>;
+        };
+        tui: {
+            showToast: (options: {
+                body: {
+                    message: string;
+                    variant: "info" | "success" | "warning" | "error";
+                };
+            }) => Promise<void>;
+        };
+        log?: {
+            debug: (message: string, meta?: Record<string, unknown>) => void;
+            info: (message: string, meta?: Record<string, unknown>) => void;
+            warn: (message: string, meta?: Record<string, unknown>) => void;
+            error: (message: string, meta?: Record<string, unknown>) => void;
+        };
+    };
+}
+interface AuthorizeResult {
+    url: string;
+    instructions?: string;
+    method: "auto" | "manual";
+    callback: () => Promise<TokenExchangeResult>;
+}
+interface TokenExchangeResult {
+    type: "success" | "failed";
+    refresh?: string;
+    access?: string;
+    expires?: number;
+    error?: string;
+    resourceUrl?: string;
+}
+interface AuthMethod {
+    label: string;
+    type: "oauth" | "api";
+    authorize?: () => Promise<AuthorizeResult>;
+    prompts?: Array<{
+        type: "text" | "password";
+        message: string;
+        key: string;
+    }>;
+}
+interface PluginResult {
+    auth?: {
+        provider: string;
+        loader: (getAuth: GetAuth, provider: Provider) => Promise<LoaderResult | Record<string, unknown>>;
+        methods: AuthMethod[];
+    };
+    tool?: Record<string, unknown>;
+}
+
+/**
+ * Main Qwen OAuth Plugin for OpenCode
+ * Provides authentication with Qwen/Alibaba Cloud DashScope API
+ */
+
+/**
+ * Main Qwen OAuth Plugin export.
+ *
+ * This plugin provides:
+ * - OAuth authentication with Qwen/Alibaba Cloud
+ * - Automatic token refresh
+ * - Request handling with proper authentication headers
+ */
+declare function QwenOAuthPlugin({ client, }: PluginContext): Promise<PluginResult>;
+
+/**
+ * Qwen OAuth Manager
+ * Handles OAuth token management for Qwen Code API
+ * Based on revibe/core/llm/backend/qwen/oauth.py
+ */
+
+/**
+ * Get the path to the cached OAuth credentials file.
+ */
+declare function getQwenCachedCredentialPath(customPath?: string): string;
+/**
+ * Manages OAuth authentication for Qwen Code API.
+ */
+declare class QwenOAuthManager {
+    private oauthPath?;
+    private credentials;
+    private refreshLock;
+    constructor(oauthPath?: string);
+    /**
+     * Load OAuth credentials from the cached file.
+     */
+    private loadCachedCredentials;
+    /**
+     * Refresh the OAuth access token.
+     */
+    refreshAccessToken(credentials: QwenOAuthCredentials): Promise<QwenOAuthCredentials>;
+    /**
+     * Save credentials to the cache file.
+     */
+    private saveCredentials;
+    /**
+     * Check if the access token is still valid.
+     */
+    private isTokenValid;
+    /**
+     * Invalidate cached credentials to force a refresh on next request.
+     */
+    invalidateCredentials(): void;
+    /**
+     * Ensure we have valid authentication credentials.
+     * @returns Tuple of [access_token, base_url]
+     */
+    ensureAuthenticated(forceRefresh?: boolean): Promise<[string, string]>;
+    /**
+     * Get the API base URL from credentials.
+     */
+    private getBaseUrl;
+    /**
+     * Get the current credentials, refreshing if needed.
+     */
+    getCredentials(): Promise<QwenOAuthCredentials>;
+}
+/**
+ * Check if OAuth credentials exist.
+ */
+declare function hasQwenCredentials(customPath?: string): boolean;
+
+/**
+ * Thinking Block Parser for Qwen
+ * Handles <think>...</think> tags in the stream to separate
+ * reasoning content from regular text content.
+ *
+ * Based on revibe/core/llm/backend/qwen/handler.py
+ */
+interface ParseResult {
+    /** Regular content (outside thinking blocks) */
+    regularContent: string;
+    /** Reasoning/thinking content (inside thinking blocks) */
+    reasoningContent: string;
+}
+/**
+ * Parser for Qwen's thinking/reasoning blocks.
+ *
+ * Handles `<think>...</think>` tags in the stream to separate
+ * reasoning content from regular text content.
+ *
+ * This parser is stateful and designed for streaming scenarios
+ * where tags might be split across multiple chunks.
+ */
+declare class ThinkingBlockParser {
+    private inThinkingBlock;
+    private buffer;
+    /**
+     * Reset the parser state.
+     * Call this when starting a new message/response.
+     */
+    reset(): void;
+    /**
+     * Check if currently inside a thinking block.
+     */
+    isInThinkingBlock(): boolean;
+    /**
+     * Parse text and separate thinking content from regular content.
+     *
+     * This method is designed for streaming - call it with each chunk
+     * of text as it arrives, and it will return the parsed content.
+     *
+     * @param text - The text chunk to parse
+     * @returns Object containing regular and reasoning content
+     */
+    parse(text: string): ParseResult;
+    /**
+     * Find if there's a partial opening tag at the end of the buffer.
+     * Returns the length of the partial tag, or 0 if none found.
+     */
+    private findPartialOpenTag;
+    /**
+     * Flush any remaining content in the buffer.
+     * Call this when the stream is complete.
+     *
+     * @returns Any remaining content based on current state
+     */
+    flush(): ParseResult;
+}
+/**
+ * Parse complete text for thinking blocks (non-streaming).
+ *
+ * Use this for non-streaming responses where the entire text is available.
+ *
+ * @param text - The complete text to parse
+ * @returns Object containing regular and reasoning content
+ */
+declare function parseThinkingBlocks(text: string): ParseResult;
+/**
+ * Remove thinking blocks from text, returning only regular content.
+ *
+ * @param text - The text to process
+ * @returns Text with thinking blocks removed
+ */
+declare function stripThinkingBlocks(text: string): string;
+/**
+ * Extract only thinking/reasoning content from text.
+ *
+ * @param text - The text to process
+ * @returns Only the content inside thinking blocks
+ */
+declare function extractThinkingContent(text: string): string;
+/**
+ * Check if text contains any thinking blocks.
+ *
+ * @param text - The text to check
+ * @returns True if text contains <think> tags
+ */
+declare function hasThinkingBlocks(text: string): boolean;
+
+/**
+ * Auth utilities for the Qwen OpenCode plugin
+ * Based on opencode-google-antigravity-auth/src/plugin/auth.ts
+ */
+
+/**
+ * Type guard to check if auth details are OAuth type.
+ */
+declare function isOAuthAuth(auth: AuthDetails): auth is OAuthAuthDetails;
+/**
+ * Parse refresh token string into its constituent parts.
+ * Format: "refreshToken|resourceUrl"
+ */
+declare function parseRefreshParts(refresh: string): RefreshParts;
+/**
+ * Serialize refresh parts back into stored string format.
+ */
+declare function formatRefreshParts(parts: RefreshParts): string;
+/**
+ * Check if an access token is expired or missing.
+ * Includes a buffer for clock skew to trigger refresh slightly early.
+ */
+declare function accessTokenExpired(auth: OAuthAuthDetails): boolean;
+/**
+ * Create auth details object for storage.
+ */
+declare function createAuthDetails(accessToken: string, refreshToken: string, expiresAt: number, resourceUrl?: string): OAuthAuthDetails;
+
+/**
+ * Token refresh utilities for the Qwen OpenCode plugin
+ * Handles refreshing OAuth access tokens when they expire
+ */
+
+/**
+ * Refresh an OAuth access token using the refresh token.
+ *
+ * @param auth - Current OAuth auth details with refresh token
+ * @param client - Plugin client for showing toasts
+ * @returns Updated auth details with new access token, or null on failure
+ */
+declare function refreshAccessToken(auth: OAuthAuthDetails, client: PluginContext["client"]): Promise<OAuthAuthDetails | null>;
+/**
+ * Check if an access token needs refresh (expired or about to expire).
+ */
+declare function needsTokenRefresh(auth: OAuthAuthDetails): boolean;
+/**
+ * Ensure we have a valid access token, refreshing if necessary.
+ *
+ * @param auth - Current auth details
+ * @param client - Plugin client for showing toasts
+ * @returns Updated auth details, or null if refresh failed
+ */
+declare function ensureValidToken(auth: OAuthAuthDetails, client: PluginContext["client"]): Promise<OAuthAuthDetails | null>;
+
+/**
+ * Qwen Code Models Configuration
+ * Defines available models and their specifications for the OpenCode plugin
+ */
+
+/**
+ * Available Qwen Code models accessible through OAuth authentication.
+ * All models are free when using OAuth.
+ */
+declare const QWEN_CODE_MODELS: Record<string, QwenModelInfo>;
+/**
+ * Model aliases mapping friendly names to actual model IDs.
+ */
+declare const MODEL_ALIASES: Record<string, string>;
+/**
+ * Default model to use when none specified.
+ */
+declare const DEFAULT_MODEL = "qwen3-coder-plus";
+/**
+ * Get model info by ID or alias.
+ *
+ * @param modelIdOrAlias - Model ID or alias name
+ * @returns Model info or undefined if not found
+ */
+declare function getModelInfo(modelIdOrAlias: string): QwenModelInfo | undefined;
+/**
+ * Resolve model alias to actual model ID.
+ *
+ * @param modelIdOrAlias - Model ID or alias name
+ * @returns Resolved model ID or the original string if not found
+ */
+declare function resolveModelId(modelIdOrAlias: string): string;
+/**
+ * Get all available model IDs (including aliases).
+ */
+declare function getAllModelIds(): string[];
+/**
+ * Check if a model ID or alias is valid.
+ */
+declare function isValidModel(modelIdOrAlias: string): boolean;
+/**
+ * Generate OpenCode provider configuration for Qwen Code models.
+ * Use this to configure models in opencode.json.
+ */
+declare function generateProviderConfig(): Record<string, unknown>;
+
+declare const QWEN_OAUTH_BASE_URL = "https://chat.qwen.ai";
+declare const QWEN_DEFAULT_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+declare const QWEN_INTL_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+declare const QWEN_PORTAL_BASE_URL = "https://portal.qwen.ai/v1";
+declare const QWEN_PROVIDER_ID = "qwencode";
+
+export { type AuthDetails, type ChatCompletionRequest, type ChatCompletionResponse, type ChatMessage, DEFAULT_MODEL, MODEL_ALIASES, type OAuthAuthDetails, type PluginContext, type PluginResult, QWEN_CODE_MODELS, QWEN_DEFAULT_BASE_URL, QWEN_INTL_BASE_URL, QWEN_OAUTH_BASE_URL, QWEN_PORTAL_BASE_URL, QWEN_PROVIDER_ID, type QwenModelInfo, type QwenOAuthCredentials, QwenOAuthManager, QwenOAuthPlugin, type QwenTokenResponse, ThinkingBlockParser, type TokenExchangeResult, type Tool, type ToolCall, type ToolChoice, accessTokenExpired, createAuthDetails, QwenOAuthPlugin as default, ensureValidToken, extractThinkingContent, formatRefreshParts, generateProviderConfig, getAllModelIds, getModelInfo, getQwenCachedCredentialPath, hasQwenCredentials, hasThinkingBlocks, isOAuthAuth, isValidModel, needsTokenRefresh, parseRefreshParts, parseThinkingBlocks, refreshAccessToken, resolveModelId, stripThinkingBlocks };