@hung319/opencode-qwen 1.1.0

package/README.md

@@ -0,0 +1,180 @@
+# OpenCode Qwen Plugin
+
+[![npm version](https://img.shields.io/npm/v/@hung319/opencode-qwen)](https://www.npmjs.com/package/@hung319/opencode-qwen)
+[![npm downloads](https://img.shields.io/npm/dm/@hung319/opencode-qwen)](https://www.npmjs.com/package/@hung319/opencode-qwen)
+[![license](https://img.shields.io/npm/l/@hung319/opencode-qwen)](https://www.npmjs.com/package/@hung319/opencode-qwen)
+
+OpenCode plugin for Qwen API providing access to Qwen AI models with auto-configuration and token management support.
+
+## Features
+
+- **Auto-update models**: Automatically fetches latest models from Qwen API every time OpenCode runs
+- **Auto-configuration**: Models are automatically configured, no manual setup needed.
+- **Token validation and refresh**: Built-in support for token validation and refresh functionality.
+- **Multi-account rotation**: Sticky and round-robin strategies for account selection.
+- **Automated token refresh** and rate limit handling with exponential backoff.
+- **Native thinking mode support** for models that support reasoning.
+- **OpenAI-compatible endpoints**: Works with familiar OpenAI API format.
+
+## Installation
+
+```bash
+npm install -g @hung319/opencode-qwen
+```
+
+Or add to your `opencode.json` with specific version:
+
+```json
+{
+  "plugin": ["@hung319/opencode-qwen@1.0.0"]
+}
+```
+
+Then select **"qwen"** from the provider list when logging in.
+
+That's it! Models are automatically configured. No manual provider configuration needed.
+
+## Quick Start
+
+### Interactive Mode
+
+```bash
+opencode auth login
+# Select: qwen → Enter  
+# Choose: API Token
+```
+
+## Configuration
+
+Optional configuration file at `~/.config/opencode/qwen.json`:
+
+```json
+{
+  "default_auth_method": "token",
+  "account_selection_strategy": "round-robin",
+  "auth_server_port_start": 8097,
+  "auth_server_port_range": 10,
+  "max_request_iterations": 50,
+  "request_timeout_ms": 300000,
+  "enable_log_api_request": false,
+  "base_url": "https://qwen.aikit.club/v1"
+}
+```
+
+### Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `default_auth_method` | Auth method (`token`) | `token` |
+| `account_selection_strategy` | Rotation strategy (`sticky`, `round-robin`) | `round-robin` |
+| `auth_server_port_start` | Port for any callback servers | `8097` |
+| `auth_server_port_range` | Number of ports to try | `10` |
+| `max_request_iterations` | Max iterations to prevent hangs | `50` |
+| `request_timeout_ms` | Request timeout in milliseconds | `300000` |
+| `enable_log_api_request` | Enable request/response logging | `false` |
+| `base_url` | Qwen API base URL | `https://qwen.aikit.club/v1` |
+
+### Environment Variables
+
+All config options can be overridden via environment variables:
+
+```bash
+export QWEN_DEFAULT_AUTH_METHOD=token
+export QWEN_ACCOUNT_SELECTION_STRATEGY=round-robin
+export QWEN_AUTH_SERVER_PORT_START=8097
+export QWEN_MAX_REQUEST_ITERATIONS=50
+export QWEN_REQUEST_TIMEOUT_MS=300000
+export QWEN_BASE_URL=https://qwen.aikit.club/v1
+```
+
+## Supported Models
+
+Models are automatically configured when you install the plugin and are fetched from the Qwen API:
+
+| Model | Description |
+|-------|-------------|
+| `qwen-max-latest` | Latest Qwen Max model |
+| `qwen3-coder-plus` | Advanced coding capabilities |
+| `qwen-deep-research` | Deep research and analysis |
+| `qwen2.5-max` | Qwen 2.5 Max model |
+| `qwen2.5-plus` | Qwen 2.5 Plus model |
+| `qwen2.5-turbo` | Fast Qwen 2.5 Turbo model |
+| `qwen-full-stack` | Full stack application development |
+| `qwen-web-dev` | Web development specialized model |
+| ... | And more models available via API |
+
+## Data Storage
+
+**Linux/macOS:**
+- Credentials: `~/.config/opencode/qwen-accounts.json`
+- Config: `~/.config/opencode/qwen.json`
+
+**Windows:**
+- Credentials: `%APPDATA%\opencode\qwen-accounts.json`
+- Config: `%APPDATA%\opencode\qwen.json`
+
+## Thinking Models
+
+Some models support thinking/reasoning mode:
+
+```json
+{
+  "model": "qwen-max-latest",
+  "enable_thinking": true,
+  "thinking_budget": 30000
+}
+```
+
+## Token Management
+
+### How to Get Your Token
+
+To obtain your Qwen API token, follow these steps:
+
+1. **Visit Qwen Chat**: Go to [chat.qwen.ai](https://chat.qwen.ai) and log in to your account
+2. **Run the Token Extractor**: Copy and paste the following JavaScript code into your browser's developer console (press F12 → Console tab):
+
+```javascript
+javascript:(function(){if(window.location.hostname!=="chat.qwen.ai"){alert("🚀 This code is for chat.qwen.ai");window.open("https://chat.qwen.ai","_blank");return;}
+function getApiKeyData(){const token=localStorage.getItem("token");if(!token){alert("❌ qwen access_token not found !!!");return null;}
+return token;}
+async function copyToClipboard(text){try{await navigator.clipboard.writeText(text);return true;}catch(err){console.error("❌ Failed to copy to clipboard:",err);const textarea=document.createElement("textarea");textarea.value=text;textarea.style.position="fixed";textarea.style.opacity="0";document.body.appendChild(textarea);textarea.focus();textarea.select();const success=document.execCommand("copy");document.body.removeChild(textarea);return success;}}
+const apiKeyData=getApiKeyData();if(!apiKeyData)return;copyToClipboard(apiKeyData).then((success)=>{if(success){alert("🔑 Qwen access_token copied to clipboard !!! 🎉");}else{prompt("🔰 Qwen access_token:",apiKeyData);}});})();
+```
+
+3. **Get Your Token**: The script will automatically:
+   - Extract your access_token from localStorage
+   - Copy the access_token to your clipboard
+
+4. **Use the Token**: The copied token is now ready to use as your `Bearer` token in API requests
+
+## Links
+
+- **NPM Package**: https://www.npmjs.com/package/@hung319/opencode-qwen
+- **GitHub Repository**: https://github.com/hung319/opencode-qwen
+- **Issues**: https://github.com/hung319/opencode-qwen/issues
+
+## License
+
+MIT
+
+## License
+
+MIT
+
+## Disclaimer
+
+This plugin is provided strictly for learning and educational purposes. It is an independent implementation and is not affiliated with, endorsed by, or supported by Alibaba Cloud or Qwen AI. Use of this plugin is at your own risk.
+
+Feel free to open a PR to optimize this plugin further.
+
+---
+
+<div align="center">
+  <p>
+    Built with ❤️ by hung319
+  </p>
+  <p>
+    <sub>If you find this project useful, please consider giving it a ⭐ on GitHub!</sub>
+  </p>
+</div>

package/dist/constants.d.ts

@@ -0,0 +1,14 @@
+export type QwenAuthMethod = 'token';
+export declare function isValidAuthMethod(method: string): method is QwenAuthMethod;
+export declare const QWEN_CONSTANTS: {
+    BASE_URL: string;
+    VALIDATE_URL: string;
+    REFRESH_URL: string;
+    USER_AGENT: string;
+    CALLBACK_PORT_START: number;
+    CALLBACK_PORT_RANGE: number;
+};
+export declare const SUPPORTED_MODELS: string[];
+export declare const THINKING_MODELS: string[];
+export declare function isThinkingModel(model: string): boolean;
+export declare function applyThinkingConfig(body: any, model: string): any;

package/dist/constants.js

@@ -0,0 +1,63 @@
+export function isValidAuthMethod(method) {
+    return method === 'token';
+}
+export const QWEN_CONSTANTS = {
+    BASE_URL: 'https://qwen.aikit.club/v1',
+    VALIDATE_URL: 'https://qwen.aikit.club/validate',
+    REFRESH_URL: 'https://qwen.aikit.club/refresh',
+    USER_AGENT: 'OpenCode-Qwen-API',
+    CALLBACK_PORT_START: 8097,
+    CALLBACK_PORT_RANGE: 10
+};
+export const SUPPORTED_MODELS = [
+    'qwen-max-latest',
+    'qwen3-coder-plus',
+    'qwen-deep-research',
+    'qwen2.5-max',
+    'qwen2.5-plus',
+    'qwen2.5-turbo',
+    'qwen2.5-14b-instruct-1m',
+    'qwen2.5-72b-instruct',
+    'qwen2.5-coder-32b-instruct',
+    'qwen2.5-omni-7b',
+    'qwen2.5-vl-32b-instruct',
+    'qwen3-235b-a22b-2507',
+    'qwen3-30b-a3b-2507',
+    'qwen3-coder',
+    'qwen3-coder-flash',
+    'qwen-web-dev',
+    'qwen-full-stack',
+    'qwen3-max',
+    'qwen3-omni-flash',
+    'qwen3-vl-235b-a22b',
+    'qwen3-vl-32b',
+    'qwen3-vl-30b-a3b',
+    'qvq-max',
+    'qwq-32b'
+];
+export const THINKING_MODELS = [
+    'qwen-max-latest',
+    'qwen3-235b-a22b-2507',
+    'qvq-max',
+    'qwq-32b',
+    'qwen2.5-max',
+    'qwen-deep-research'
+];
+export function isThinkingModel(model) {
+    return THINKING_MODELS.some((m) => model.startsWith(m));
+}
+export function applyThinkingConfig(body, model) {
+    const enableThinking = body.enable_thinking;
+    const thinkingBudget = body.thinking_budget;
+    if (enableThinking || thinkingBudget) {
+        const result = { ...body };
+        if (enableThinking !== undefined) {
+            result.enable_thinking = enableThinking;
+        }
+        if (thinkingBudget) {
+            result.thinking_budget = thinkingBudget;
+        }
+        return result;
+    }
+    return body;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { QwenOAuthPlugin } from './plugin.js';
+export type { QwenConfig } from './plugin/config/index.js';
+export type { QwenAuthMethod, ManagedAccount } from './plugin/types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { QwenOAuthPlugin } from './plugin.js';

package/dist/plugin/accounts.d.ts

@@ -0,0 +1,27 @@
+import type { ManagedAccount } from './types';
+export declare function generateAccountId(): string;
+export declare class AccountManager {
+    private accounts;
+    private strategy;
+    private currentIndex;
+    private toastShown;
+    constructor(strategy?: 'sticky' | 'round-robin');
+    static loadFromDisk(strategy?: 'sticky' | 'round-robin'): Promise<AccountManager>;
+    saveToDisk(): Promise<void>;
+    getAccounts(): ManagedAccount[];
+    getAccountCount(): number;
+    addAccount(account: ManagedAccount): void;
+    removeAccount(account: ManagedAccount): void;
+    getCurrentOrNext(): ManagedAccount | null;
+    markRateLimited(account: ManagedAccount, retryAfterMs: number): void;
+    markUnhealthy(account: ManagedAccount, reason: string, nextCheckAt: number): void;
+    markHealthy(account: ManagedAccount): void;
+    getMinWaitTime(): number;
+    shouldShowToast(): boolean;
+    toAuthDetails(account: ManagedAccount): {
+        apiKey: string;
+        email: string;
+        expiresAt: number | undefined;
+    };
+    updateFromAuth(account: ManagedAccount, authResult: any): void;
+}

package/dist/plugin/accounts.js

@@ -0,0 +1,149 @@
+import { v4 as uuidv4 } from 'uuid';
+import { Storage } from './storage';
+export function generateAccountId() {
+    return `qwen_acc_${Date.now()}_${uuidv4().substring(0, 8)}`;
+}
+export class AccountManager {
+    accounts = [];
+    strategy;
+    currentIndex = 0;
+    toastShown = false;
+    constructor(strategy = 'round-robin') {
+        this.strategy = strategy;
+    }
+    static async loadFromDisk(strategy = 'round-robin') {
+        const manager = new AccountManager(strategy);
+        const storageData = await Storage.read();
+        if (storageData) {
+            manager.accounts = storageData.accounts;
+        }
+        return manager;
+    }
+    async saveToDisk() {
+        const storageData = {
+            accounts: this.accounts,
+            createdAt: this.accounts.length > 0 ? Math.min(...this.accounts.map(a => a.lastUsed || Date.now())) : Date.now(),
+            updatedAt: Date.now()
+        };
+        await Storage.write(storageData);
+    }
+    getAccounts() {
+        return this.accounts;
+    }
+    getAccountCount() {
+        return this.accounts.length;
+    }
+    addAccount(account) {
+        // Check if account already exists (by email/apiKey)
+        const existingIndex = this.accounts.findIndex(acc => acc.email === account.email || acc.apiKey === account.apiKey);
+        if (existingIndex !== -1) {
+            // Update existing account
+            this.accounts[existingIndex] = { ...this.accounts[existingIndex], ...account };
+        }
+        else {
+            // Add new account
+            this.accounts.push(account);
+        }
+    }
+    removeAccount(account) {
+        const index = this.accounts.findIndex(acc => acc.id === account.id);
+        if (index !== -1) {
+            this.accounts.splice(index, 1);
+        }
+    }
+    getCurrentOrNext() {
+        if (this.accounts.length === 0) {
+            return null;
+        }
+        // Remove expired rate limits
+        const now = Date.now();
+        this.accounts = this.accounts.filter(acc => acc.rateLimitResetTime < now);
+        // Find first healthy account
+        if (this.strategy === 'round-robin') {
+            // Find first healthy account, starting from current index
+            for (let i = 0; i < this.accounts.length; i++) {
+                const index = (this.currentIndex + i) % this.accounts.length;
+                const account = this.accounts[index];
+                if (account && account.isHealthy && account.rateLimitResetTime < now) {
+                    this.currentIndex = (index + 1) % this.accounts.length;
+                    account.lastUsed = now;
+                    this.toastShown = false;
+                    return account;
+                }
+            }
+        }
+        else { // sticky strategy
+            // Try to use the same account as last time, if still healthy
+            if (this.accounts.length > 0) {
+                const currentAccount = this.accounts[this.currentIndex % this.accounts.length];
+                if (currentAccount && currentAccount.isHealthy && currentAccount.rateLimitResetTime < now) {
+                    currentAccount.lastUsed = now;
+                    this.toastShown = false;
+                    return currentAccount;
+                }
+            }
+            // If current account is unhealthy, find any healthy one
+            for (let i = 0; i < this.accounts.length; i++) {
+                const account = this.accounts[i];
+                if (account && account.isHealthy && account.rateLimitResetTime < now) {
+                    this.currentIndex = i;
+                    account.lastUsed = now;
+                    this.toastShown = false;
+                    return account;
+                }
+            }
+        }
+        return null;
+    }
+    markRateLimited(account, retryAfterMs) {
+        const acc = this.accounts.find(a => a.id === account.id);
+        if (acc) {
+            acc.rateLimitResetTime = Date.now() + retryAfterMs;
+            acc.isHealthy = false;
+        }
+    }
+    markUnhealthy(account, reason, nextCheckAt) {
+        const acc = this.accounts.find(a => a.id === account.id);
+        if (acc) {
+            acc.isHealthy = false;
+            acc.rateLimitResetTime = nextCheckAt;
+        }
+    }
+    markHealthy(account) {
+        const acc = this.accounts.find(a => a.id === account.id);
+        if (acc) {
+            acc.isHealthy = true;
+            acc.rateLimitResetTime = 0;
+        }
+    }
+    getMinWaitTime() {
+        if (this.accounts.length === 0)
+            return 0;
+        const now = Date.now();
+        const waits = this.accounts
+            .filter(acc => acc.rateLimitResetTime > now)
+            .map(acc => acc.rateLimitResetTime - now);
+        return waits.length > 0 ? Math.min(...waits) : 0;
+    }
+    shouldShowToast() {
+        const should = !this.toastShown;
+        this.toastShown = true;
+        return should;
+    }
+    toAuthDetails(account) {
+        return {
+            apiKey: account.apiKey,
+            email: account.email,
+            expiresAt: account.expiresAt
+        };
+    }
+    updateFromAuth(account, authResult) {
+        const acc = this.accounts.find(a => a.id === account.id);
+        if (acc) {
+            acc.accessToken = authResult.accessToken;
+            acc.refreshToken = authResult.refreshToken;
+            acc.expiresAt = authResult.expiresAt;
+            acc.apiKey = authResult.accessToken;
+        }
+    }
+}

package/dist/plugin/cli.d.ts

@@ -0,0 +1,9 @@
+export declare function promptAddAnotherAccount(currentCount: number): Promise<boolean>;
+export declare function promptLoginMode(existingAccounts: Array<{
+    email: string;
+    index: number;
+}>): Promise<'fresh' | 'add'>;
+export declare function promptAuthMethod(): Promise<'token'>;
+export declare function promptToken(): Promise<string>;
+export declare function promptEmail(): Promise<string>;
+export declare function promptOAuthCallback(): Promise<string>;

package/dist/plugin/cli.js

@@ -0,0 +1,37 @@
+import { createInterface } from 'readline';
+const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+function question(prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, resolve);
+    });
+}
+export async function promptAddAnotherAccount(currentCount) {
+    const response = await question(`\nCurrent account count: ${currentCount}. Add another account? (y/N): `);
+    return ['y', 'yes', 'Y', 'YES'].includes(response.trim());
+}
+export async function promptLoginMode(existingAccounts) {
+    console.log('\nYou have existing accounts:');
+    existingAccounts.forEach((acc, idx) => {
+        console.log(`${idx + 1}. ${acc.email}`);
+    });
+    const response = await question('\nChoose login mode:\n1. Fresh (replace existing accounts)\n2. Add (keep existing accounts)\nEnter 1 or 2: ');
+    return response.trim() === '1' ? 'fresh' : 'add';
+}
+export async function promptAuthMethod() {
+    return 'token';
+}
+export async function promptToken() {
+    const token = await question('Enter your Qwen API token: ');
+    return token.trim();
+}
+export async function promptEmail() {
+    const email = await question('Enter email for this account (optional): ');
+    return email.trim() || 'qwen-token-user';
+}
+export async function promptOAuthCallback() {
+    const input = await question('Paste the callback URL or authorization code: ');
+    return input.trim();
+}

package/dist/plugin/config/index.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+declare const configSchema: z.ZodObject<{
+    default_auth_method: z.ZodDefault<z.ZodEnum<["token"]>>;
+    account_selection_strategy: z.ZodDefault<z.ZodEnum<["sticky", "round-robin"]>>;
+    auth_server_port_start: z.ZodDefault<z.ZodNumber>;
+    auth_server_port_range: z.ZodDefault<z.ZodNumber>;
+    max_request_iterations: z.ZodDefault<z.ZodNumber>;
+    request_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    enable_log_api_request: z.ZodDefault<z.ZodBoolean>;
+    base_url: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    default_auth_method: "token";
+    account_selection_strategy: "sticky" | "round-robin";
+    auth_server_port_start: number;
+    auth_server_port_range: number;
+    max_request_iterations: number;
+    request_timeout_ms: number;
+    enable_log_api_request: boolean;
+    base_url: string;
+}, {
+    default_auth_method?: "token" | undefined;
+    account_selection_strategy?: "sticky" | "round-robin" | undefined;
+    auth_server_port_start?: number | undefined;
+    auth_server_port_range?: number | undefined;
+    max_request_iterations?: number | undefined;
+    request_timeout_ms?: number | undefined;
+    enable_log_api_request?: boolean | undefined;
+    base_url?: string | undefined;
+}>;
+export type QwenConfig = z.infer<typeof configSchema>;
+export declare function loadConfig(): QwenConfig;
+export {};

package/dist/plugin/config/index.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+const configSchema = z.object({
+    default_auth_method: z.enum(['token']).default('token'),
+    account_selection_strategy: z.enum(['sticky', 'round-robin']).default('round-robin'),
+    auth_server_port_start: z.number().default(8097),
+    auth_server_port_range: z.number().default(10),
+    max_request_iterations: z.number().default(50),
+    request_timeout_ms: z.number().default(300000),
+    enable_log_api_request: z.boolean().default(false),
+    base_url: z.string().default('https://qwen.aikit.club/v1')
+});
+const CONFIG_FILE_PATH = join(os.homedir(), '.config', 'opencode', 'qwen.json');
+export function loadConfig() {
+    let config = {};
+    // Load from file if it exists
+    try {
+        const fileContent = readFileSync(CONFIG_FILE_PATH, 'utf8');
+        config = JSON.parse(fileContent);
+    }
+    catch (error) {
+        // File doesn't exist or is invalid, use empty config
+    }
+    // Override with environment variables
+    const envConfig = {};
+    if (process.env.QWEN_DEFAULT_AUTH_METHOD)
+        envConfig.default_auth_method = process.env.QWEN_DEFAULT_AUTH_METHOD;
+    if (process.env.QWEN_ACCOUNT_SELECTION_STRATEGY)
+        envConfig.account_selection_strategy = process.env.QWEN_ACCOUNT_SELECTION_STRATEGY;
+    if (process.env.QWEN_AUTH_SERVER_PORT_START)
+        envConfig.auth_server_port_start = parseInt(process.env.QWEN_AUTH_SERVER_PORT_START, 10);
+    if (process.env.QWEN_AUTH_SERVER_PORT_RANGE)
+        envConfig.auth_server_port_range = parseInt(process.env.QWEN_AUTH_SERVER_PORT_RANGE, 10);
+    if (process.env.QWEN_MAX_REQUEST_ITERATIONS)
+        envConfig.max_request_iterations = parseInt(process.env.QWEN_MAX_REQUEST_ITERATIONS, 10);
+    if (process.env.QWEN_REQUEST_TIMEOUT_MS)
+        envConfig.request_timeout_ms = parseInt(process.env.QWEN_REQUEST_TIMEOUT_MS, 10);
+    if (process.env.QWEN_ENABLE_LOG_API_REQUEST)
+        envConfig.enable_log_api_request = process.env.QWEN_ENABLE_LOG_API_REQUEST === 'true';
+    if (process.env.QWEN_BASE_URL)
+        envConfig.base_url = process.env.QWEN_BASE_URL;
+    // Merge and validate
+    const finalConfig = { ...config, ...envConfig };
+    return configSchema.parse(finalConfig);
+}

package/dist/plugin/errors.d.ts

@@ -0,0 +1,11 @@
+export declare class QwenTokenRefreshError extends Error {
+    originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+export declare class QwenAuthenticationError extends Error {
+    constructor(message: string);
+}
+export declare class QwenRateLimitError extends Error {
+    retryAfter?: number | undefined;
+    constructor(message: string, retryAfter?: number | undefined);
+}

package/dist/plugin/errors.js

@@ -0,0 +1,22 @@
+export class QwenTokenRefreshError extends Error {
+    originalError;
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = 'QwenTokenRefreshError';
+    }
+}
+export class QwenAuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'QwenAuthenticationError';
+    }
+}
+export class QwenRateLimitError extends Error {
+    retryAfter;
+    constructor(message, retryAfter) {
+        super(message);
+        this.retryAfter = retryAfter;
+        this.name = 'QwenRateLimitError';
+    }
+}

package/dist/plugin/logger.d.ts

@@ -0,0 +1,23 @@
+export declare function setLogging(enabled: boolean): void;
+export declare function log(message: string, ...optionalParams: any[]): void;
+export declare function warn(message: string, ...optionalParams: any[]): void;
+export declare function error(message: string, ...optionalParams: any[]): void;
+export declare function getTimestamp(): string;
+interface ApiRequestData {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: any;
+    account: string;
+}
+interface ApiResponseData {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body?: string;
+    account: string;
+}
+export declare function logApiRequest(request: ApiRequestData, timestamp: string): void;
+export declare function logApiResponse(response: ApiResponseData, timestamp: string): void;
+export declare function logApiError(request: ApiRequestData, response: ApiResponseData, timestamp: string): void;
+export {};

package/dist/plugin/logger.js

@@ -0,0 +1,40 @@
+let enableLogging = false;
+export function setLogging(enabled) {
+    enableLogging = enabled;
+}
+export function log(message, ...optionalParams) {
+    if (enableLogging) {
+        console.log(`[qwen-plugin] ${message}`, ...optionalParams);
+    }
+}
+export function warn(message, ...optionalParams) {
+    console.warn(`[qwen-plugin] ${message}`, ...optionalParams);
+}
+export function error(message, ...optionalParams) {
+    console.error(`[qwen-plugin] ${message}`, ...optionalParams);
+}
+export function getTimestamp() {
+    return new Date().toISOString();
+}
+export function logApiRequest(request, timestamp) {
+    if (enableLogging) {
+        console.log(`[qwen-plugin] [${timestamp}] API REQUEST: ${request.method} ${request.url}`);
+        console.log(`[qwen-plugin] [${timestamp}] Account: ${request.account}`);
+        console.log(`[qwen-plugin] [${timestamp}] Headers:`, request.headers);
+        console.log(`[qwen-plugin] [${timestamp}] Body:`, JSON.stringify(request.body, null, 2));
+    }
+}
+export function logApiResponse(response, timestamp) {
+    if (enableLogging) {
+        console.log(`[qwen-plugin] [${timestamp}] API RESPONSE: ${response.status} ${response.statusText}`);
+        console.log(`[qwen-plugin] [${timestamp}] Account: ${response.account}`);
+        console.log(`[qwen-plugin] [${timestamp}] Response:`, response.body || 'No body');
+    }
+}
+export function logApiError(request, response, timestamp) {
+    console.error(`[qwen-plugin] [${timestamp}] API ERROR: ${response.status} ${response.statusText}`);
+    console.error(`[qwen-plugin] [${timestamp}] URL: ${request.url}`);
+    console.error(`[qwen-plugin] [${timestamp}] Account: ${response.account}`);
+    console.error(`[qwen-plugin] [${timestamp}] Request body:`, JSON.stringify(request.body, null, 2));
+    console.error(`[qwen-plugin] [${timestamp}] Response:`, response.body);
+}