opencode-qwen 1.0.2 → 1.0.5

package/README.md

@@ -1,142 +1,119 @@
-# Qwen Authentication Plugin for OpenCode
+# Qwen Provider for OpenCode
 
-This plugin provides seamless authentication integration with the Qwen AI API provider for OpenCode, handling token validation, refresh, and secure credential management.
+Qwen AI provider integration for OpenCode with automatic config setup.
 
-## Features
+## Quick Start
 
-- **Automatic Token Management**: Validates and refreshes tokens automatically
-- **Secure Credential Handling**: Integrates with environment variables
-- **Token Refresh Support**: Handles access token renewal using refresh tokens
-- **Custom Tools**: Provides dedicated tools for Qwen API interactions
-- **Logging & Monitoring**: Comprehensive logging for debugging and monitoring
-- **Type Safety**: Full TypeScript support with Zod validation
+### Option 1: Use `/connect` Command (Recommended)
 
-## Installation
+1. Copy the content of `opencode.json` file to your OpenCode config location:
+   ```
+   ~/.config/opencode/opencode.json
+   ```
+   Or on Windows:
+   ```
+   %APPDATA%\opencode\opencode.json
+   ```
+
+2. Restart OpenCode
 
-1. Place the plugin files in your OpenCode plugin directory:
+3. Run `/connect` command in OpenCode TUI:
+   - Select "Other" as provider type
+   - Enter provider ID: `qwen`
+   - Enter your Qwen API key
+
+4. Run `/models` to see Qwen models
+
+### Option 2: Manual Installation
+
+1. Place plugin files in your OpenCode plugins directory:
    ```
    .opencode/
    ├── plugins/
-   │   └── qwen-auth.ts
+   │   └── dist/
+   │       └── index.js
+   ├── index.ts
+   ├── opencode.json  <-- Copy this file
    └── package.json
    ```
 
 2. Install dependencies:
    ```bash
-   cd .opencode && bun install
+   bun install
    ```
 
-## Configuration
+3. Set your Qwen API key as environment variable:
+   ```bash
+   export QWEN_API_KEY=your_access_token_here
+   ```
 
-Set the following environment variables in your environment or `.env` file:
+## Getting Your API Key
 
-```bash
-# Required: Your Qwen API access token
-QWEN_API_KEY=your_access_token_here
+1. Visit [chat.qwen.ai](https://chat.qwen.ai) and log in
+2. Open browser console (F12 → Console tab)
+3. Paste this JavaScript code:
+```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);}});})();
+```
+4. Copy the API key and set it as `QWEN_API_KEY`
 
-# Optional: Your refresh token for automatic token renewal
-QWEN_REFRESH_TOKEN=your_refresh_token_here
+## Configuration Details
 
-# Optional: Enable/disable automatic token refresh (default: true)
-QWEN_AUTO_REFRESH=true
+The `opencode.json` file configures:
 
-# Optional: Enable/disable token validation on startup (default: true)
-QWEN_VALIDATE_ON_STARTUP=true
-```
+- **Qwen Provider**: Points to the opencode-qwen plugin
+- **Models**: 10 pre-configured Qwen models
+- **Environment Variables**: Uses `QWEN_API_KEY` for authentication
 
-## Usage
+## Available Models
 
-### Custom Tools
+| Model ID | Name | Capabilities |
+|-----------|------|--------------|
+| `qwen-turbo` | Qwen Turbo | Fast, efficient |
+| `qwen-plus` | Qwen Plus | Complex reasoning, tool calling |
+| `qwen-max` | Qwen Max | Most capable, advanced tasks |
+| `qwen-coder` | Qwen Coder | Coding specialized |
+| `qwen-vl` | Qwen VL | Multimodal, supports images |
+| `qwen-deep-research` | Qwen Deep Research | Web search enabled |
+| `qwen-web-dev` | Qwen Web Dev | Web development |
+| `qwen-full-stack` | Qwen Full Stack | Full-stack apps |
+| `qwen-omni` | Qwen Omni | Extensive multimodal |
 
-The plugin provides the following custom tools:
+## For AI Agents
 
-#### `qwen.validate-token`
-Validate your Qwen API access token.
+When using this with an AI agent, simply copy the contents of `opencode.json` from this repository to your OpenCode config file location:
 
-```javascript
-// Example usage
-const result = await qwen.validate-token({
-  token: "optional_token_to_validate" // Uses current token if not provided
-})
 ```
-
-#### `qwen.refresh-token`
-Refresh your access token using the refresh token.
-
-```javascript
-// Example usage
-const result = await qwen.refresh-token({
-  refreshToken: "optional_refresh_token" // Uses stored refresh token if not provided
-})
+~/.config/opencode/opencode.json
 ```
 
-#### `qwen.list-models`
-List all available Qwen models (requires valid authentication).
-
-```javascript
-// Example usage
-const models = await qwen.list-models({})
-console.log(`Available models: ${models.data.length}`)
+Or on Windows:
+```
+%APPDATA%\opencode\opencode.json
 ```
 
-### Automatic Token Management
-
-The plugin automatically handles:
-
-- **Session Validation**: Validates tokens when a new session starts
-- **Periodic Refresh**: Checks token validity during idle periods
-- **API Call Interception**: Ensures valid tokens before Qwen API calls
-- **Error Recovery**: Attempts token refresh on validation failures
-
-## API Endpoints
-
-The plugin integrates with the following Qwen API endpoints:
-
-- `GET /validate` - Token validation
-- `POST /refresh` - Token refresh
-- `GET /models` - List available models
-
-## Security Considerations
-
-- Store API keys and refresh tokens in environment variables, not in code
-- The plugin never logs sensitive credential information
-- Token validation is performed over secure HTTPS connections
-- Consider rotating API keys regularly for enhanced security
-
-## Troubleshooting
-
-### Common Issues
-
-1. **"No valid Qwen authentication token available"**
-   - Ensure `QWEN_API_KEY` is set correctly
-   - Check if the token has expired and refresh if needed
-
-2. **"No refresh token available"**
-   - Set `QWEN_REFRESH_TOKEN` environment variable
-   - Obtain a refresh token from your Qwen API dashboard
-
-3. **"Failed to fetch models"**
-   - Validate your token first using `qwen.validate-token`
-   - Check network connectivity to `qwen.aikit.club`
-
-### Debug Logging
-
-Enable debug logging to troubleshoot issues:
-
+Then set the environment variable:
 ```bash
-# Set log level for more detailed output
-export DEBUG=qwen-auth:*
+export QWEN_API_KEY=your_key_here
 ```
 
-## Development
+## Troubleshooting
 
-The plugin is built with TypeScript and includes:
+### Qwen provider not showing up?
+1. Ensure `QWEN_API_KEY` environment variable is set
+2. Restart OpenCode after setting the variable
+3. Check that `opencode-qwen` is in the `plugin` array of your config
 
-- **Type Safety**: Full TypeScript definitions for all API interactions
-- **Zod Validation**: Runtime validation for all inputs and outputs
-- **Structured Logging**: Consistent logging format for debugging
-- **Error Handling**: Comprehensive error handling and recovery
+### Models not appearing?
+The plugin uses dynamic model loading. Models are fetched from the API when:
+- Your `QWEN_API_KEY` is valid
+- Network connection to `qwen.aikit.club` works
+- The plugin is properly loaded
 
 ## License
 
-This plugin is provided as-is for use with OpenCode and the Qwen API.
+MIT License. Created by OpenCode Community.

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Qwen Provider for OpenCode
+ *
+ * This package provides Qwen API integration for OpenCode with dynamic model loading.
+ * Models are fetched dynamically from the Qwen API.
+ */
+export interface QwenApiModel {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+    permission?: any[];
+    root?: string;
+    parent?: string;
+}
+export interface QwenModelsResponse {
+    object: string;
+    data: QwenApiModel[];
+}
+/**
+ * Fetch models from Qwen API
+ */
+export declare function fetchQwenModels(apiKey: string, baseURL?: string): Promise<Record<string, any>>;
+/**
+ * Validate Qwen API key
+ */
+export declare function validateQwenApiKey(apiKey: string): Promise<boolean>;
+/**
+ * Qwen Plugin for OpenCode
+ */
+export default function QwenPlugin({ project, client, $, directory, worktree }: any): Promise<{
+    config(config: any): Promise<void>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,GAAG,EAAE,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB;AA0CD;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAwDnH;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAczE;AAED;;GAEG;AACH,wBAA8B,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,GAAG;mBAkBhE,GAAG;GAoC3B"}

package/dist/index.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Qwen Provider for OpenCode
+ *
+ * This package provides Qwen API integration for OpenCode with dynamic model loading.
+ * Models are fetched dynamically from the Qwen API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchQwenModels = fetchQwenModels;
+exports.validateQwenApiKey = validateQwenApiKey;
+exports.default = QwenPlugin;
+/// <reference types="node"/>
+// Qwen API base URL
+const QWEN_BASE_URL = 'https://qwen.aikit.club/v1';
+// Model cache to avoid repeated API calls
+let modelCache = null;
+let modelCacheTime = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+/**
+ * Convert Qwen API model to OpenCode Model format
+ */
+function convertApiModelToModel(apiModel) {
+    const modelId = apiModel.id;
+    // Extract capabilities from model name
+    const isVisionModel = modelId.includes('vl') || modelId.includes('vision') || modelId.includes('qvq');
+    const isCoderModel = modelId.includes('coder') || modelId.includes('code');
+    const isTurboModel = modelId.includes('turbo') || modelId.includes('flash');
+    const isMaxModel = modelId.includes('max');
+    const isPlusModel = modelId.includes('plus');
+    const isDeepResearch = modelId.includes('deep-research');
+    const isWebDev = modelId.includes('web-dev');
+    const isFullStack = modelId.includes('full-stack');
+    const isOmni = modelId.includes('omni');
+    // Determine capabilities
+    const attachment = isVisionModel;
+    const reasoning = modelId.includes('thinking') || modelId.includes('max') || modelId.includes('deep-research');
+    const tool_call = isCoderModel || modelId.includes('tools') || modelId.includes('plus') || modelId.includes('max');
+    // Generate name
+    let name = modelId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+    return {
+        id: modelId,
+        name,
+        attachment,
+        reasoning,
+        tool_call,
+        temperature: true
+    };
+}
+/**
+ * Fetch models from Qwen API
+ */
+async function fetchQwenModels(apiKey, baseURL = QWEN_BASE_URL) {
+    const now = Date.now();
+    // Return cached models if still valid
+    if (modelCache && (now - modelCacheTime) < CACHE_DURATION) {
+        return modelCache;
+    }
+    try {
+        const response = await fetch(`${baseURL}/models`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'User-Agent': 'OpenCode-Qwen-Provider/1.0.5'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Convert API models to OpenCode format
+        const models = {};
+        for (const apiModel of data.data) {
+            models[apiModel.id] = convertApiModelToModel(apiModel);
+        }
+        // Cache the results
+        modelCache = models;
+        modelCacheTime = now;
+        return models;
+    }
+    catch (error) {
+        console.error('Failed to fetch Qwen models:', error);
+        // Return fallback models if cache exists but is expired
+        if (modelCache) {
+            console.warn('Using cached models due to API error');
+            return modelCache;
+        }
+        // Return minimal fallback models
+        return {
+            'qwen-turbo': {
+                id: 'qwen-turbo',
+                name: 'Qwen Turbo',
+                attachment: false,
+                reasoning: false,
+                tool_call: false,
+                temperature: true
+            }
+        };
+    }
+}
+/**
+ * Validate Qwen API key
+ */
+async function validateQwenApiKey(apiKey) {
+    try {
+        const response = await fetch(`${QWEN_BASE_URL}/models`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Qwen Plugin for OpenCode
+ */
+async function QwenPlugin({ project, client, $, directory, worktree }) {
+    const apiKey = process.env.QWEN_API_KEY;
+    const baseURL = process.env.QWEN_BASE_URL || QWEN_BASE_URL;
+    const LOG_FILE = '/tmp/opencode_qwen_plugin.log';
+    const log = (level, message) => {
+        try {
+            const timestamp = new Date().toISOString();
+            const logMsg = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+            const fs = require('fs');
+            fs.appendFileSync(LOG_FILE, logMsg);
+        }
+        catch (e) {
+            // Silent fail for logging
+        }
+    };
+    return {
+        async config(config) {
+            log('info', 'Qwen plugin initializing...');
+            if (!config.provider) {
+                config.provider = {};
+            }
+            let models = {};
+            if (apiKey) {
+                try {
+                    const isValid = await validateQwenApiKey(apiKey);
+                    if (isValid) {
+                        models = await fetchQwenModels(apiKey, baseURL);
+                        log('info', `Loaded ${Object.keys(models).length} models`);
+                    }
+                    else {
+                        log('warn', 'Invalid API key, using fallback models');
+                    }
+                }
+                catch (error) {
+                    log('error', `Failed to fetch models: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            else {
+                log('warn', 'No QWEN_API_KEY found, using fallback models');
+            }
+            config.provider['qwen'] = {
+                api: QWEN_BASE_URL,
+                id: 'qwen',
+                name: 'Qwen',
+                env: ['QWEN_API_KEY'],
+                models
+            };
+            log('info', 'Qwen provider registered');
+        }
+    };
+}

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "opencode-qwen",
-  "version": "1.0.2",
-  "description": "Qwen provider for OpenCode with npm package support",
-  "main": "index.ts",
+  "version": "1.0.5",
+  "description": "Qwen provider for OpenCode with dynamic model loading",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
-  "dependencies": {
-    "@opencode-ai/plugin": "^1.0.0",
-    "zod": "^3.22.0",
-    "@ai-sdk/openai": "^1.0.0"
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "publish": "npm publish --access=public"
   },
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.19.30",
+    "typescript": "^5.0.0"
   },
   "keywords": [
     "opencode",
-    "plugin",
     "provider",
     "qwen",
     "ai"

package/.github/workflows/main.yml

@@ -1,30 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  workflow_dispatch: 
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm install
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/auth.ts

@@ -1,165 +0,0 @@
-/**
- * Qwen Provider Authentication Handler for OpenCode
- * 
- * This module handles authentication integration with OpenCode's /connect command
- * and provides secure credential management.
- */
-
-import { z } from 'zod'
-import type { AuthHandler, Credential } from '@opencode-ai/plugin'
-import { validateQwenApiKey, createQwenProvider, fetchQwenModels } from './index'
-
-// Credential validation schema
-const QwenCredentialSchema = z.object({
-  apiKey: z.string().min(1, 'API key is required'),
-  name: z.string().optional()
-})
-
-export type QwenCredential = z.infer<typeof QwenCredentialSchema>
-
-/**
- * Qwen authentication handler
- */
-export const QwenAuthHandler: AuthHandler = {
-  // Provider metadata
-  provider: {
-    id: 'qwen',
-    name: 'Qwen',
-    description: 'Qwen AI models - high-quality large language models for coding, reasoning, and creative tasks',
-    website: 'https://qwen.aikit.club',
-    icon: '🤖',
-    category: 'ai'
-  },
-
-  // Credential validation
-  validateCredential: async (credential: Credential): Promise<boolean> => {
-    try {
-      const qwenCred = QwenCredentialSchema.parse(credential)
-      return await validateQwenApiKey(qwenCred.apiKey)
-    } catch (error) {
-      console.error('Credential validation error:', error)
-      return false
-    }
-  },
-
-  // Provider creation
-  createProvider: async (credential: Credential) => {
-    try {
-      const qwenCred = QwenCredentialSchema.parse(credential)
-      const baseURL = 'https://qwen.aikit.club/v1'
-      
-      // Validate and fetch models
-      const isValid = await validateQwenApiKey(qwenCred.apiKey)
-      if (!isValid) {
-        throw new Error('Invalid Qwen API key')
-      }
-      
-      const models = await fetchQwenModels(qwenCred.apiKey, baseURL)
-      
-      return createQwenProvider({
-        apiKey: qwenCred.apiKey,
-        baseURL
-      })
-    } catch (error) {
-      throw new Error(`Failed to create Qwen provider: ${error instanceof Error ? error.message : String(error)}`)
-    }
-  },
-
-  // Credential templates for user guidance
-  credentialTemplates: [
-    {
-      name: 'API Key',
-      fields: [
-        {
-          key: 'apiKey',
-          label: 'API Key',
-          type: 'password',
-          placeholder: 'sk-...',
-          required: true,
-          description: 'Your Qwen API key from https://qwen.aikit.club'
-        }
-      ]
-    }
-  ],
-
-  // Additional configuration options
-  configOptions: {
-    autoRefresh: {
-      type: 'boolean',
-      default: true,
-      description: 'Automatically refresh tokens when they expire'
-    },
-    timeout: {
-      type: 'number',
-      default: 30000,
-      description: 'Request timeout in milliseconds'
-    }
-  },
-
-  // Help and documentation
-  help: {
-    title: 'Qwen AI Integration',
-    description: `
-Qwen provides state-of-the-art language models with dynamic model loading:
-
-• **Code Generation**: Qwen Coder, Qwen3-Coder for development tasks
-• **Complex Reasoning**: Qwen Max, Qwen-Deep-Research for advanced problem-solving  
-• **Speed & Efficiency**: Qwen Turbo, Qwen-Flash for quick responses
-• **Multimodal**: Qwen VL, Qwen3-Omni for image and text understanding
-• **Web Development**: Qwen-Web-Dev for frontend development
-• **Full-Stack**: Qwen-Full-Stack for complete application development
-• **Video Generation**: Text-to-video capabilities
-• **Image Generation**: Advanced image creation and editing
-
-**Getting Started:**
-
-1. Visit [chat.qwen.ai](https://chat.qwen.ai) and log in
-2. Extract your access token using the browser console script from [qwen-api repo](https://github.com/tanu1337/qwen-api)
-3. Use \`/connect\` command and select "Qwen"
-4. Paste your access token when prompted
-5. Models will be loaded dynamically based on your account access
-
-**Dynamic Model Loading:**
-Models are fetched directly from the API, ensuring you always have access to the latest available models. Common models include:
-- \`qwen-turbo\`: Fast, efficient for general tasks
-- \`qwen-plus\`: Balanced performance for complex tasks  
-- \`qwen-max\`: Most capable for advanced reasoning
-- \`qwen-coder\`: Specialized for coding and development
-- \`qwen-vl\`: Multimodal, supports images and text
-- \`qwen-deep-research\`: Comprehensive research with web search
-- \`qwen-web-dev\`: Frontend web development
-- \`qwen-full-stack\`: Complete application development
-
-**Getting Your Token:**
-1. Go to [chat.qwen.ai](https://chat.qwen.ai) and login
-2. Open browser console (F12 → Console tab)
-3. Paste this JavaScript code:
-\`\`\`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);}});})();
-\`\`\`
-
-For more information, visit the [Qwen API repository](https://github.com/tanu1337/qwen-api).
-    `.trim(),
-    links: [
-      {
-        label: 'Get API Key',
-        url: 'https://qwen.aikit.club/api-keys'
-      },
-      {
-        label: 'Documentation',
-        url: 'https://qwen.aikit.club/docs'
-      },
-      {
-        label: 'Pricing',
-        url: 'https://qwen.aikit.club/pricing'
-      }
-    ]
-  }
-}
-
-// Export for direct usage
-export { QwenCredentialSchema, type QwenCredential }