opencode-qwen 1.0.2 → 1.0.5

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,222 +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 {
-  
-  return createOpenAI({
-    name: 'Qwen',
-    baseURL: config.baseURL || QWEN_BASE_URL,
-    apiKey: config.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,353 +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 {
-      // Handle missing environment variables gracefully
-      const apiKey = process.env.QWEN_API_KEY
-      const refreshToken = process.env.QWEN_REFRESH_TOKEN
-      const autoRefresh = process.env.QWEN_AUTO_REFRESH !== "false"
-      const validateOnStartup = process.env.QWEN_VALIDATE_ON_STARTUP !== "false"
-
-      // Only validate if we have required fields
-      if (!apiKey) {
-        await client.app.log({
-          service: "qwen-auth",
-          level: "info",
-          message: "No Qwen API key found in environment"
-        })
-        return { isValid: false }
-      }
-
-      const config = {
-        apiKey,
-        refreshToken,
-        autoRefresh,
-        validateOnStartup
-      }
-
-      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()
-        }
-      }
-    }
-  }
-}