@hung319/opencode-qwen 1.1.0

package/dist/qwen/models.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Auto-update models from Qwen API
+ * Fetches available models from the Qwen API proxy
+ */
+export interface QwenModelInfoMeta {
+    profile_image_url?: string;
+    description?: string;
+    capabilities?: {
+        vision?: boolean;
+        document?: boolean;
+        video?: boolean;
+        audio?: boolean;
+        citations?: boolean;
+        thinking?: boolean;
+    };
+    short_description?: string;
+    max_context_length?: number;
+    max_generation_length?: number;
+    max_summary_generation_length?: number;
+    max_thinking_generation_length?: number;
+    abilities?: {
+        vision?: number;
+        document?: number;
+        video?: number;
+        audio?: number;
+        citations?: number;
+        thinking?: number;
+    };
+    chat_type?: string[];
+    modality?: string[];
+    [key: string]: any;
+}
+export interface QwenModelInfo {
+    id: string;
+    name: string;
+    meta: QwenModelInfoMeta;
+    [key: string]: any;
+}
+export interface QwenModel {
+    id: string;
+    name: string;
+    object: string;
+    owned_by?: string;
+    info: QwenModelInfo;
+    preset: boolean;
+    action_ids: string[];
+}
+export interface QwenModelsResponse {
+    object: string;
+    data: QwenModel[];
+}
+/**
+ * Fetch models from Qwen API
+ * @param apiKey - API key or token
+ */
+export declare function fetchModelsFromAPI(apiKey: string): Promise<QwenModel[] | null>;
+/**
+ * Transform Qwen models to OpenCode format
+ */
+export declare function transformModelsToOpenCode(models: QwenModel[]): Record<string, any>;
+/**
+ * Get cached models or fetch new ones
+ */
+export declare function getModels(apiKey: string | undefined): Promise<Record<string, any>>;

package/dist/qwen/models.js

@@ -0,0 +1,113 @@
+/**
+ * Auto-update models from Qwen API
+ * Fetches available models from the Qwen API proxy
+ */
+import * as logger from '../plugin/logger.js';
+/**
+ * Fetch models from Qwen API
+ * @param apiKey - API key or token
+ */
+export async function fetchModelsFromAPI(apiKey) {
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'accept': 'application/json'
+        };
+        const response = await fetch(`${process.env.QWEN_BASE_URL || 'https://qwen.aikit.club'}/v1/models`, {
+            method: 'GET',
+            headers,
+        });
+        if (!response.ok) {
+            logger.warn(`Failed to fetch models: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        const data = await response.json();
+        logger.log(`Successfully fetched ${data.data?.length || 0} models from Qwen API`);
+        return data.data || null;
+    }
+    catch (error) {
+        logger.warn(`Error fetching models from API: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * Transform Qwen models to OpenCode format
+ */
+export function transformModelsToOpenCode(models) {
+    const result = {};
+    for (const model of models) {
+        // Extract capabilities from model info
+        const meta = model.info?.meta || {};
+        const capabilities = meta.capabilities || {};
+        const abilities = meta.abilities || {};
+        // Determine modalities based on capabilities
+        const modalities = {
+            input: ['text'],
+            output: ['text']
+        };
+        if (capabilities.vision || model.id.includes('vl') || model.id.includes('vision') || meta.modality?.includes('image')) {
+            modalities.input.push('image');
+        }
+        if (capabilities.video || meta.modality?.includes('video')) {
+            modalities.input.push('video');
+        }
+        if (capabilities.audio || meta.modality?.includes('audio')) {
+            modalities.input.push('audio');
+        }
+        if (capabilities.document || meta.modality?.includes('document')) {
+            modalities.input.push('document');
+        }
+        // Determine context and output limits
+        let contextLimit = meta.max_context_length || 128000;
+        let outputLimit = meta.max_generation_length || meta.max_summary_generation_length || 8000;
+        // Special handling for specific model types
+        if (model.id.includes('max') || model.id.includes('235b') || model.id.includes('80b') || model.id.includes('next')) {
+            contextLimit = meta.max_context_length || 1000000; // 1M tokens for max models
+        }
+        else if (model.id.includes('turbo')) {
+            contextLimit = meta.max_context_length || 1000000; // 1M tokens for turbo models
+            outputLimit = meta.max_generation_length || 8000;
+        }
+        else if (model.id.includes('omni')) {
+            contextLimit = meta.max_context_length || 65536;
+            outputLimit = meta.max_generation_length || 13684;
+        }
+        // Create the model configuration
+        result[model.id] = {
+            name: model.name || model.id,
+            limit: {
+                context: contextLimit,
+                output: outputLimit,
+            },
+            modalities: modalities,
+            // Add thinking mode support if available
+            ...(capabilities.thinking || abilities.thinking ? { supports_thinking: true } : {}),
+            // Add description if available
+            ...(meta.description ? { description: meta.description } : {}),
+            // Add short description if available
+            ...(meta.short_description ? { short_description: meta.short_description } : {}),
+            // Add additional info as needed
+            info: {
+                owned_by: model.owned_by,
+                preset: model.preset,
+                capabilities: capabilities
+            }
+        };
+    }
+    return result;
+}
+/**
+ * Get cached models or fetch new ones
+ */
+export async function getModels(apiKey) {
+    // Try to fetch from API if credentials available
+    if (apiKey) {
+        const apiModels = await fetchModelsFromAPI(apiKey);
+        if (apiModels) {
+            return transformModelsToOpenCode(apiModels);
+        }
+    }
+    // Return empty object if unable to fetch
+    return {};
+}

package/dist/qwen/token.d.ts

@@ -0,0 +1,13 @@
+export interface QwenTokenResult {
+    apiKey: string;
+    email?: string;
+    authMethod: 'token';
+    expiresAt?: number;
+}
+export declare function validateToken(apiKey: string): Promise<QwenTokenResult>;
+export interface QwenRefreshResponse {
+    timestamp: number;
+    expires_at: string;
+    access_token: string;
+}
+export declare function refreshToken(currentToken: string): Promise<QwenTokenResult>;

package/dist/qwen/token.js

@@ -0,0 +1,85 @@
+import { QWEN_CONSTANTS } from '../constants';
+export async function validateToken(apiKey) {
+    // First validate using header-based auth
+    const response = await fetch(`${QWEN_CONSTANTS.BASE_URL}/models`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'User-Agent': QWEN_CONSTANTS.USER_AGENT
+        }
+    });
+    if (!response.ok) {
+        // Try validation endpoint with token in request body as fallback
+        const validateResponse = await fetch(QWEN_CONSTANTS.VALIDATE_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': QWEN_CONSTANTS.USER_AGENT
+            },
+            body: JSON.stringify({ token: apiKey })
+        });
+        if (!validateResponse.ok) {
+            const errorText = await validateResponse.text().catch(() => '');
+            throw new Error(`Token validation failed: ${validateResponse.status} - ${errorText}`);
+        }
+    }
+    // Try to get user info if possible, but don't fail if not available
+    let email;
+    try {
+        // Attempt to get more user information using models endpoint
+        const modelsResponse = await fetch(`${QWEN_CONSTANTS.BASE_URL}/models`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'User-Agent': QWEN_CONSTANTS.USER_AGENT
+            }
+        });
+        if (modelsResponse.ok) {
+            const modelsData = await modelsResponse.json();
+            // If the API returns user-specific data, extract it here
+        }
+    }
+    catch (e) {
+        // If we can't get user details, that's OK - we still have a valid token
+        console.debug('Could not fetch user details, but token is valid');
+    }
+    return {
+        apiKey,
+        email: email || 'qwen-token-user',
+        authMethod: 'token'
+    };
+}
+export async function refreshToken(currentToken) {
+    const response = await fetch(QWEN_CONSTANTS.REFRESH_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': QWEN_CONSTANTS.USER_AGENT
+        },
+        body: JSON.stringify({ token: currentToken })
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.access_token) {
+        throw new Error('Refresh token response did not contain new access token');
+    }
+    // Validate the new token and return with expiration information
+    const validatedToken = await validateToken(data.access_token);
+    // Try to extract expiration time from the response
+    let expiresAt;
+    if (data.expires_at) {
+        // Try to parse the expiration time from the string format
+        // Format: "2026-03-15 01:46:05 UTC (2026-03-15 07:16:05 IST, UTC+05:30)"
+        const match = data.expires_at.match(/(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) UTC/);
+        if (match && match[1]) {
+            const dateStr = match[1] + ' UTC';
+            const expiresDate = new Date(dateStr);
+            expiresAt = expiresDate.getTime();
+        }
+    }
+    return {
+        ...validatedToken,
+        ...(expiresAt && { expiresAt })
+    };
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@hung319/opencode-qwen",
+  "version": "1.1.0",
+  "description": "OpenCode plugin for Qwen API providing access to Qwen AI models with auto-config and token management",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "format": "prettier --write --no-config --no-semi --single-quote --trailing-comma none --print-width 100 'src/**/*.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "qwen",
+    "claude",
+    "gpt",
+    "gemini",
+    "ai",
+    "auth",
+    "token"
+  ],
+  "author": "hung319",
+  "license": "MIT",
+  "homepage": "https://www.npmjs.com/package/@hung319/opencode-qwen",
+  "bugs": {
+    "url": "https://github.com/hung319/opencode-qwen/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hung319/opencode-qwen.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^0.15.30",
+    "proper-lockfile": "^4.1.2",
+    "tiktoken": "^1.0.17",
+    "uuid": "^9.0.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "prettier": "^3.4.2",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "typescript": "^5.7.3"
+  },
+  "opencode": {
+    "type": "plugin",
+    "hooks": [
+      "auth",
+      "event"
+    ]
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ]
+}