opencode-qwen 1.0.1 → 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.1",
-  "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 }

package/fix_summary.md

@@ -1,28 +0,0 @@
-## Qwen Plugin Import Fix Summary
-
-**Problem Identified:**
-The plugin was failing to load because it was trying to import `createOpenAI` from the non-existent package `@ai-sdk/openai-compatible`, but this function actually exists in `@ai-sdk/openai`.
-
-**Root Cause:**
-- Package `@ai-sdk/openai-compatible` doesn't exist in the OpenCode environment
-- Function `createOpenAI` is available in `@ai-sdk/openai` package
-- Multiple files had incorrect import statements
-
-**Fixes Applied:**
-1. Fixed import in `/root/workspace/opencode-qwen/index.ts`:
-   - Changed: `import { createOpenAI } from '@ai-sdk/openai-compatible'`
-   - To: `import { createOpenAI } from '@ai-sdk/openai'`
-
-2. Fixed dependency in `/root/workspace/opencode-qwen/package.json`:
-   - Changed: `"@ai-sdk/openai-compatible": "^1.0.0"`
-   - To: `"@ai-sdk/openai": "^1.0.0"` (will need version update)
-
-**Next Steps:**
-- Update package.json dependency version to match available @ai-sdk/openai version
-- Restart OpenCode to test the fix
-- Monitor logs to ensure plugin loads successfully
-
-**Technical Details:**
-- Available @ai-sdk/openai version: 3.0.23
-- The createOpenAI function is confirmed to exist in @ai-sdk/openai/dist/index.mjs
-- Plugin should now be able to load without import errors

package/index.ts

@@ -1,223 +0,0 @@
-/**
- * Qwen Provider for OpenCode
- * 
- * This package provides Qwen API integration for OpenCode following the provider specification.
- * It supports both direct API key usage and token refresh capabilities.
- * Models are fetched dynamically from the API.
- */
-
-import { createOpenAI } from '@ai-sdk/openai'
-import type { Provider, Model } from '@ai-sdk/provider'
-import { z } from 'zod'
-
-// Qwen API base URL
-const QWEN_BASE_URL = 'https://qwen.aikit.club/v1'
-
-// Qwen model interface from API response
-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[]
-}
-
-// Model cache to avoid repeated API calls
-let modelCache: Record<string, Model> | null = null
-let modelCacheTime = 0
-const CACHE_DURATION = 5 * 60 * 1000 // 5 minutes
-
-// Configuration schema for Qwen provider
-const QwenConfigSchema = z.object({
-  apiKey: z.string().min(1, 'API key is required'),
-  baseURL: z.string().default(QWEN_BASE_URL),
-  refreshToken: z.string().optional(),
-  autoRefresh: z.boolean().default(true),
-  timeout: z.number().default(30000)
-})
-
-export type QwenConfig = z.infer<typeof QwenConfigSchema>
-
-/**
- * Convert Qwen API model to OpenCode Model format
- */
-function convertApiModelToModel(apiModel: QwenApiModel): Model {
-  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 supported capabilities
-  const supports: string[] = ['text']
-  if (isVisionModel) supports.push('image')
-  if (modelId.includes('search') || modelId.includes('plus') || modelId.includes('max')) supports.push('web_search')
-  if (isCoderModel || modelId.includes('tools') || modelId.includes('plus') || modelId.includes('max')) supports.push('tools')
-  if (modelId.includes('thinking') || modelId.includes('max')) supports.push('thinking')
-  
-  // Determine max tokens based on model
-  let maxTokens = 8192
-  if (modelId.includes('32b') || modelId.includes('80b') || modelId.includes('235b') || 
-      modelId.includes('max') || modelId.includes('plus') || isCoderModel) {
-    maxTokens = 32768
-  } else if (modelId.includes('14b')) {
-    maxTokens = 8192
-  } else if (modelId.includes('72b')) {
-    maxTokens = 32768
-  }
-  
-  // Generate description
-  let description = ''
-  if (isTurboModel) description = 'Fast and efficient model for general tasks'
-  else if (isMaxModel) description = 'Most capable model for advanced tasks'
-  else if (isPlusModel) description = 'Balanced model for complex reasoning'
-  else if (isCoderModel) description = 'Specialized model for coding and development'
-  else if (isDeepResearch) description = 'Research model with comprehensive analysis capabilities'
-  else if (isWebDev) description = 'Specialized for web development and UI generation'
-  else if (isFullStack) description = 'Full-stack application development model'
-  else if (isVisionModel) description = 'Multimodal model supporting text and image analysis'
-  else description = 'Qwen language model'
-  
-  return {
-    name: apiModel.id.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
-    provider: 'Qwen',
-    maxTokens,
-    supports,
-    description
-  }
-}
-
-/**
- * Fetch models from Qwen API
- */
-export async function fetchQwenModels(apiKey: string, baseURL: string = QWEN_BASE_URL): Promise<Record<string, Model>> {
-  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.0'
-      }
-    })
-    
-    if (!response.ok) {
-      throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`)
-    }
-    
-    const data: QwenModelsResponse = await response.json()
-    
-    // Convert API models to OpenCode format
-    const models: Record<string, Model> = {}
-    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': {
-        name: 'Qwen Turbo',
-        provider: 'Qwen',
-        maxTokens: 8192,
-        supports: ['text'],
-        description: 'Fast and efficient model for general tasks'
-      }
-    }
-  }
-}
-
-/**
- * Create Qwen provider instance
- */
-export function createQwenProvider(config: QwenConfig): Provider {
-  const validatedConfig = QwenConfigSchema.parse(config)
-  
-  return createOpenAI({
-    name: 'Qwen',
-    baseURL: validatedConfig.baseURL,
-    apiKey: validatedConfig.apiKey,
-    headers: {
-      'User-Agent': 'OpenCode-Qwen-Provider/1.0.0'
-    },
-    compatibility: 'compatible'
-  })
-}
-
-/**
- * Validate Qwen API key
- */
-export async function validateQwenApiKey(apiKey: string): Promise<boolean> {
-  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
-  }
-}
-
-/**
- * Get available Qwen models (requires API key for dynamic loading)
- */
-export async function getQwenModels(apiKey: string, baseURL?: string): Promise<Record<string, Model>> {
-  return await fetchQwenModels(apiKey, baseURL)
-}
-
-/**
- * Provider factory for OpenCode integration
- */
-export default function qwenProvider() {
-  return {
-    id: 'qwen',
-    name: 'Qwen',
-    description: 'Qwen AI models - high-quality large language models with dynamic model loading',
-    website: 'https://qwen.aikit.club',
-    create: createQwenProvider,
-    validate: validateQwenApiKey,
-    getModels: fetchQwenModels
-  }
-}
-
-// Export types for TypeScript users
-export type { QwenConfig }

package/opencode.example.json

@@ -1,34 +0,0 @@
-# Example OpenCode configuration with Qwen auth plugin
-
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugins": [
-    "./plugins/qwen-auth.ts"
-  ],
-  "tools": {
-    "qwen": {
-      "baseUrl": "https://qwen.aikit.club/v1",
-      "apiKey": "${QWEN_API_KEY}"
-    }
-  },
-  "env": {
-    "QWEN_API_KEY": {
-      "description": "Qwen API access token",
-      "required": true
-    },
-    "QWEN_REFRESH_TOKEN": {
-      "description": "Qwen API refresh token for automatic renewal",
-      "required": false
-    },
-    "QWEN_AUTO_REFRESH": {
-      "description": "Enable automatic token refresh",
-      "default": "true",
-      "type": "boolean"
-    },
-    "QWEN_VALIDATE_ON_STARTUP": {
-      "description": "Validate token on session startup",
-      "default": "true", 
-      "type": "boolean"
-    }
-  }
-}

package/qwen-auth.ts

@@ -1,337 +0,0 @@
-/**
- * Qwen Provider Authentication Plugin for OpenCode
- * 
- * This plugin handles authentication for the Qwen API provider,
- * including token validation, refresh, and secure credential management.
- */
-
-import type { Plugin, tool } from "@opencode-ai/plugin"
-import { z } from "zod"
-
-// Qwen API base URL
-const QWEN_API_BASE = "https://qwen.aikit.club/v1"
-
-// TypeScript types for Qwen authentication
-export interface QwenAuthState {
-  accessToken?: string
-  refreshToken?: string
-  expiresAt?: number
-  isValid: boolean
-  lastValidated?: number
-}
-
-export interface QwenTokenResponse {
-  access_token: string
-  refresh_token?: string
-  expires_in: number
-  token_type: string
-}
-
-export interface QwenModel {
-  id: string
-  object: string
-  created: number
-  owned_by: string
-}
-
-export interface QwenModelsResponse {
-  object: string
-  data: QwenModel[]
-}
-
-// Zod schemas for validation
-const QwenAuthConfigSchema = z.object({
-  apiKey: z.string().min(1, "API key is required"),
-  refreshToken: z.string().optional(),
-  autoRefresh: z.boolean().default(true),
-  validateOnStartup: z.boolean().default(true)
-})
-
-const ValidateTokenSchema = z.object({
-  token: z.string().optional()
-})
-
-const RefreshTokenSchema = z.object({
-  refreshToken: z.string().optional()
-})
-
-/**
- * Qwen Authentication Plugin
- */
-export const QwenAuthPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
-  let authState: QwenAuthState = {
-    isValid: false
-  }
-
-  /**
-   * Load authentication state from environment or secure storage
-   */
-  const loadAuthState = async (): Promise<QwenAuthState> => {
-    try {
-      const config = QwenAuthConfigSchema.parse({
-        apiKey: process.env.QWEN_API_KEY,
-        refreshToken: process.env.QWEN_REFRESH_TOKEN,
-        autoRefresh: process.env.QWEN_AUTO_REFRESH !== 'false',
-        validateOnStartup: process.env.QWEN_VALIDATE_ON_STARTUP !== 'false'
-      })
-
-      authState = {
-        accessToken: config.apiKey,
-        refreshToken: config.refreshToken,
-        isValid: !!config.apiKey,
-        lastValidated: Date.now()
-      }
-
-      await client.app.log({
-        service: "qwen-auth",
-        level: "info",
-        message: "Auth state loaded",
-        extra: { hasToken: !!config.apiKey, hasRefreshToken: !!config.refreshToken }
-      })
-
-      return authState
-    } catch (error) {
-      await client.app.log({
-        service: "qwen-auth",
-        level: "error",
-        message: "Failed to load auth state",
-        extra: { error: error instanceof Error ? error.message : String(error) }
-      })
-      return { isValid: false }
-    }
-  }
-
-  /**
-   * Validate current access token
-   */
-  const validateToken = async (token?: string): Promise<boolean> => {
-    try {
-      const tokenToValidate = token || authState.accessToken
-      if (!tokenToValidate) {
-        return false
-      }
-
-      const response = await fetch(`${QWEN_API_BASE}/validate`, {
-        method: "GET",
-        headers: {
-          "Authorization": `Bearer ${tokenToValidate}`,
-          "Content-Type": "application/json"
-        }
-      })
-
-      const isValid = response.ok
-      authState.isValid = isValid
-      authState.lastValidated = Date.now()
-
-      await client.app.log({
-        service: "qwen-auth",
-        level: isValid ? "info" : "warn",
-        message: `Token validation ${isValid ? 'successful' : 'failed'}`,
-        extra: { status: response.status }
-      })
-
-      return isValid
-    } catch (error) {
-      authState.isValid = false
-      await client.app.log({
-        service: "qwen-auth",
-        level: "error",
-        message: "Token validation error",
-        extra: { error: error instanceof Error ? error.message : String(error) }
-      })
-      return false
-    }
-  }
-
-  /**
-   * Refresh access token using refresh token
-   */
-  const refreshToken = async (refreshTokenValue?: string): Promise<boolean> => {
-    try {
-      const tokenToUse = refreshTokenValue || authState.refreshToken
-      if (!tokenToUse) {
-        await client.app.log({
-          service: "qwen-auth",
-          level: "warn",
-          message: "No refresh token available"
-        })
-        return false
-      }
-
-      const response = await fetch(`${QWEN_API_BASE}/refresh`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          refresh_token: tokenToUse
-        })
-      })
-
-      if (!response.ok) {
-        throw new Error(`Refresh failed: ${response.status}`)
-      }
-
-      const tokenData: QwenTokenResponse = await response.json()
-      
-      authState.accessToken = tokenData.access_token
-      if (tokenData.refresh_token) {
-        authState.refreshToken = tokenData.refresh_token
-      }
-      authState.expiresAt = Date.now() + (tokenData.expires_in * 1000)
-      authState.isValid = true
-      authState.lastValidated = Date.now()
-
-      await client.app.log({
-        service: "qwen-auth",
-        level: "info",
-        message: "Token refreshed successfully",
-        extra: { expiresIn: tokenData.expires_in }
-      })
-
-      return true
-    } catch (error) {
-      await client.app.log({
-        service: "qwen-auth",
-        level: "error",
-        message: "Token refresh failed",
-        extra: { error: error instanceof Error ? error.message : String(error) }
-      })
-      return false
-    }
-  }
-
-  /**
-   * Auto-refresh token if needed
-   */
-  const ensureValidToken = async (): Promise<boolean> => {
-    if (!authState.accessToken) {
-      await loadAuthState()
-    }
-
-    if (authState.isValid && authState.lastValidated && 
-        Date.now() - authState.lastValidated < 5 * 60 * 1000) {
-      return true // Valid within last 5 minutes
-    }
-
-    const isValid = await validateToken()
-    if (isValid) {
-      return true
-    }
-
-    if (authState.refreshToken) {
-      return await refreshToken()
-    }
-
-    return false
-  }
-
-  // Initialize plugin
-  await loadAuthState()
-
-  return {
-    // Custom tools for Qwen authentication
-    tool: {
-      "qwen.validate-token": tool({
-        description: "Validate Qwen API access token",
-        args: ValidateTokenSchema,
-        async execute(args, context) {
-          const isValid = await validateToken(args.token)
-          return {
-            valid: isValid,
-            timestamp: new Date().toISOString(),
-            state: authState
-          }
-        }
-      }),
-
-      "qwen.refresh-token": tool({
-        description: "Refresh Qwen API access token",
-        args: RefreshTokenSchema,
-        async execute(args, context) {
-          const success = await refreshToken(args.refreshToken)
-          return {
-            success,
-            timestamp: new Date().toISOString(),
-            state: authState
-          }
-        }
-      }),
-
-      "qwen.list-models": tool({
-        description: "List available Qwen models (requires valid authentication)",
-        args: z.object({}),
-        async execute(args, context) {
-          await ensureValidToken()
-          
-          if (!authState.accessToken || !authState.isValid) {
-            throw new Error("No valid Qwen authentication token available")
-          }
-
-          try {
-            const response = await fetch(`${QWEN_API_BASE}/models`, {
-              headers: {
-                "Authorization": `Bearer ${authState.accessToken}`,
-                "Content-Type": "application/json"
-              }
-            })
-
-            if (!response.ok) {
-              throw new Error(`Failed to fetch models: ${response.status}`)
-            }
-
-            const models: QwenModelsResponse = await response.json()
-            
-            await client.app.log({
-              service: "qwen-auth",
-              level: "info",
-              message: `Successfully retrieved ${models.data.length} models`
-            })
-
-            return models
-          } catch (error) {
-            await client.app.log({
-              service: "qwen-auth",
-              level: "error",
-              message: "Failed to fetch models",
-              extra: { error: error instanceof Error ? error.message : String(error) }
-            })
-            throw error
-          }
-        }
-      })
-    },
-
-    // Hooks for automatic token management
-    "tool.execute.before": async (input, output) => {
-      // Intercept Qwen API calls and ensure valid authentication
-      if (input.tool === "bash" && output.args.command?.includes("qwen.aikit.club")) {
-        await ensureValidToken()
-        if (authState.accessToken) {
-          // Inject token into command if needed
-          output.args.command = output.args.command.replace(
-            /qwen\.aikit\.club\/v1\//,
-            `qwen.aikit.club/v1/?api_key=${authState.accessToken}&`
-          )
-        }
-      }
-    },
-
-    "session.created": async () => {
-      // Validate token on session creation if enabled
-      if (process.env.QWEN_VALIDATE_ON_STARTUP !== 'false') {
-        await ensureValidToken()
-      }
-    },
-
-    "session.idle": async () => {
-      // Periodic validation when session is idle
-      if (authState.isValid && authState.lastValidated) {
-        const timeSinceValidation = Date.now() - authState.lastValidated
-        if (timeSinceValidation > 30 * 60 * 1000) { // 30 minutes
-          await validateToken()
-        }
-      }
-    }
-  }
-}