qwen.js 0.1.0 → 0.1.1

package/dist/auth.d.ts

@@ -1,14 +1,8 @@
-import type { AuthState } from "./types";
-export declare class QwenAuth {
-    private clientId;
-    private scope;
-    private verifier;
-    private deviceCode;
-    constructor(clientId?: string, scope?: string);
-    requestDeviceCode(): Promise<{
-        url: string;
-        userCode: string;
-    }>;
-    pollForToken(maxAttempts?: number, intervalMs?: number): Promise<AuthState>;
-    refreshToken(refreshToken: string): Promise<AuthState>;
-}
+import type { PKCEPair, DeviceCodeResponse, TokenResponse, TokenState } from "./types";
+declare const CLIENT_ID = "f0304373b74a44d2b584a3fb70ca9e56";
+export declare function generatePKCE(): Promise<PKCEPair>;
+export declare function requestDeviceCode(challenge: string): Promise<DeviceCodeResponse>;
+export declare function pollForToken(deviceCode: string, verifier: string, interval: number): Promise<TokenResponse>;
+export declare function refreshAccessToken(refreshToken: string): Promise<TokenResponse>;
+export declare function isTokenExpired(state: TokenState): boolean;
+export { CLIENT_ID };

package/dist/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client.d.ts

@@ -1,23 +1,22 @@
-import type { ChatMessage, ChatRequest, ChatResponse, AuthState } from "./types";
+import type { QwenConfig, ChatMessage, ChatOptions, ChatResponse, TokenState } from "./types";
 export declare class QwenClient {
-    private auth;
-    private authState;
+    private tokens;
     private model;
-    constructor(options?: {
-        accessToken?: string;
-        refreshToken?: string;
-        model?: string;
-    });
+    private pendingAuth;
+    constructor(config?: QwenConfig);
     login(): Promise<{
         url: string;
         userCode: string;
     }>;
     waitForAuth(): Promise<void>;
-    authenticate(): Promise<string>;
+    authenticate(): Promise<void>;
     setTokens(accessToken: string, refreshToken?: string): void;
-    getTokens(): AuthState | null;
-    private ensureAuth;
-    chat(messages: ChatMessage[] | string, options?: Partial<ChatRequest>): Promise<ChatResponse>;
-    chatStream(messages: ChatMessage[] | string, options?: Partial<ChatRequest>): AsyncGenerator<string, void, unknown>;
-    ask(prompt: string, options?: Partial<ChatRequest>): Promise<string>;
+    getTokens(): TokenState | null;
+    private getValidToken;
+    private request;
+    chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+    chatStream(messages: ChatMessage[] | string, options?: ChatOptions): AsyncGenerator<string, void, unknown>;
+    ask(prompt: string, options?: ChatOptions): Promise<string>;
+    setModel(model: string): void;
+    getModel(): string;
 }

package/dist/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { QwenClient } from "./client";
-export { QwenAuth } from "./auth";
-export type { QwenConfig, ChatMessage, ChatRequest, ChatResponse, StreamChunk, AuthState, DeviceCodeResponse, TokenResponse, } from "./types";
+export { generatePKCE, requestDeviceCode, pollForToken, refreshAccessToken, isTokenExpired, } from "./auth";
+export type { QwenConfig, ChatMessage, ChatOptions, ChatResponse, ChatSession, StreamChunk, TokenState, DeviceCodeResponse, TokenResponse, PKCEPair, } from "./types";
 import { QwenClient } from "./client";
-export declare function createQwen(options?: {
+export declare function createQwen(config?: {
     accessToken?: string;
     refreshToken?: string;
     model?: string;

package/dist/index.js

@@ -1,128 +1,125 @@
 // src/auth.ts
-var DEFAULT_CLIENT_ID = "f0304373b74a44d2b584a3fb70ca9e56";
-var DEFAULT_SCOPE = "openid profile email model.completion";
-var AUTH_BASE_URL = "https://chat.qwen.ai/api/v1/oauth2";
-function generateVerifier() {
+var CLIENT_ID = "f0304373b74a44d2b584a3fb70ca9e56";
+var SCOPE = "openid profile email model.completion";
+var AUTH_BASE = "https://chat.qwen.ai/api/v1/oauth2";
+async function generatePKCE() {
   const array = new Uint8Array(32);
   crypto.getRandomValues(array);
-  return btoa(String.fromCharCode(...array)).replace(/\//g, "").replace(/=/g, "").replace(/\+/g, "").slice(0, 43);
-}
-async function generateChallenge(verifier) {
+  const verifier = btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "").slice(0, 43);
   const encoder = new TextEncoder;
   const data = encoder.encode(verifier);
   const hash = await crypto.subtle.digest("SHA-256", data);
-  return btoa(String.fromCharCode(...new Uint8Array(hash))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  const challenge = btoa(String.fromCharCode(...new Uint8Array(hash))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  return { verifier, challenge };
 }
-
-class QwenAuth {
-  clientId;
-  scope;
-  verifier = null;
-  deviceCode = null;
-  constructor(clientId, scope) {
-    this.clientId = clientId ?? DEFAULT_CLIENT_ID;
-    this.scope = scope ?? DEFAULT_SCOPE;
-  }
-  async requestDeviceCode() {
-    this.verifier = generateVerifier();
-    const challenge = await generateChallenge(this.verifier);
-    const response = await fetch(`${AUTH_BASE_URL}/device/code`, {
+async function requestDeviceCode(challenge) {
+  const response = await fetch(`${AUTH_BASE}/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      scope: SCOPE,
+      code_challenge: challenge,
+      code_challenge_method: "S256"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Device code request failed: ${response.status} - ${error}`);
+  }
+  return response.json();
+}
+async function pollForToken(deviceCode, verifier, interval) {
+  while (true) {
+    await new Promise((r) => setTimeout(r, interval * 1000));
+    const response = await fetch(`${AUTH_BASE}/token`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({
-        client_id: this.clientId,
-        scope: this.scope,
-        code_challenge: challenge,
-        code_challenge_method: "S256"
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        client_id: CLIENT_ID,
+        device_code: deviceCode,
+        code_verifier: verifier
       })
     });
-    if (!response.ok) {
-      throw new Error(`Device code request failed: ${response.status}`);
+    if (response.ok) {
+      return response.json();
     }
     const data = await response.json();
-    this.deviceCode = data.device_code;
-    return {
-      url: data.verification_uri_complete,
-      userCode: data.user_code
-    };
-  }
-  async pollForToken(maxAttempts = 60, intervalMs = 2000) {
-    if (!this.verifier || !this.deviceCode) {
-      throw new Error("Call requestDeviceCode() first");
+    if (data.error === "authorization_pending") {
+      continue;
     }
-    for (let i = 0;i < maxAttempts; i++) {
-      const response = await fetch(`${AUTH_BASE_URL}/token`, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-          client_id: this.clientId,
-          device_code: this.deviceCode,
-          code_verifier: this.verifier
-        })
-      });
-      const data = await response.json();
-      if (data.access_token) {
-        return {
-          accessToken: data.access_token,
-          refreshToken: data.refresh_token,
-          expiresAt: Date.now() + data.expires_in * 1000
-        };
-      }
-      if (data.error === "authorization_pending") {
-        await new Promise((r) => setTimeout(r, intervalMs));
-        continue;
-      }
-      throw new Error(data.error_description ?? data.error ?? "Token exchange failed");
+    if (data.error === "slow_down") {
+      interval += 1;
+      continue;
     }
-    throw new Error("Authorization timeout");
+    throw new Error(`Token poll failed: ${data.error_description || data.error}`);
   }
-  async refreshToken(refreshToken) {
-    const response = await fetch(`${AUTH_BASE_URL}/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: refreshToken,
-        client_id: this.clientId
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Token refresh failed: ${response.status}`);
-    }
-    const data = await response.json();
-    return {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      expiresAt: Date.now() + data.expires_in * 1000
-    };
+}
+async function refreshAccessToken(refreshToken) {
+  const response = await fetch(`${AUTH_BASE}/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: CLIENT_ID
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${response.status} - ${error}`);
   }
+  return response.json();
+}
+function isTokenExpired(state) {
+  return Date.now() >= state.expiresAt - 60000;
 }
 
 // src/client.ts
-var API_BASE_URL = "https://portal.qwen.ai/v1";
+var API_BASE = "https://portal.qwen.ai/v1";
 var DEFAULT_MODEL = "qwen-plus";
+var TOKEN_LIFETIME_MS = 6 * 60 * 60 * 1000;
 
 class QwenClient {
-  auth;
-  authState = null;
+  tokens = null;
   model;
-  constructor(options = {}) {
-    this.auth = new QwenAuth;
-    this.model = options.model ?? DEFAULT_MODEL;
-    if (options.accessToken) {
-      this.authState = {
-        accessToken: options.accessToken,
-        refreshToken: options.refreshToken ?? "",
-        expiresAt: Date.now() + 6 * 60 * 60 * 1000
+  pendingAuth = null;
+  constructor(config) {
+    this.model = config?.model ?? DEFAULT_MODEL;
+    if (config?.accessToken) {
+      this.tokens = {
+        accessToken: config.accessToken,
+        refreshToken: config.refreshToken ?? "",
+        expiresAt: Date.now() + TOKEN_LIFETIME_MS
       };
     }
   }
   async login() {
-    return this.auth.requestDeviceCode();
+    const pkce = await generatePKCE();
+    const response = await requestDeviceCode(pkce.challenge);
+    this.pendingAuth = {
+      deviceCode: response.device_code,
+      verifier: pkce.verifier,
+      interval: response.interval
+    };
+    return {
+      url: response.verification_uri_complete,
+      userCode: response.user_code
+    };
   }
   async waitForAuth() {
-    this.authState = await this.auth.pollForToken();
+    if (!this.pendingAuth) {
+      throw new Error("Call login() first");
+    }
+    const { deviceCode, verifier, interval } = this.pendingAuth;
+    const tokenResponse = await pollForToken(deviceCode, verifier, interval);
+    this.tokens = {
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt: Date.now() + tokenResponse.expires_in * 1000
+    };
+    this.pendingAuth = null;
   }
   async authenticate() {
     const { url, userCode } = await this.login();
@@ -130,72 +127,70 @@ class QwenClient {
 Open this URL to authenticate:
 ${url}
 `);
-    console.log(`Your code: ${userCode}
+    console.log(`Code: ${userCode}
 `);
+    console.log("Waiting for authorization...");
     await this.waitForAuth();
-    return this.authState.accessToken;
+    console.log(`Authenticated successfully!
+`);
   }
   setTokens(accessToken, refreshToken) {
-    this.authState = {
+    this.tokens = {
       accessToken,
       refreshToken: refreshToken ?? "",
-      expiresAt: Date.now() + 6 * 60 * 60 * 1000
+      expiresAt: Date.now() + TOKEN_LIFETIME_MS
     };
   }
   getTokens() {
-    return this.authState;
+    return this.tokens ? { ...this.tokens } : null;
   }
-  async ensureAuth() {
-    if (!this.authState) {
-      throw new Error("Not authenticated. Call login() and waitForAuth() first, or use setTokens()");
+  async getValidToken() {
+    if (!this.tokens) {
+      throw new Error("Not authenticated. Call authenticate() or setTokens() first");
     }
-    if (this.authState.refreshToken && Date.now() > this.authState.expiresAt - 5 * 60 * 1000) {
-      this.authState = await this.auth.refreshToken(this.authState.refreshToken);
+    if (isTokenExpired(this.tokens) && this.tokens.refreshToken) {
+      const newTokens = await refreshAccessToken(this.tokens.refreshToken);
+      this.tokens = {
+        accessToken: newTokens.access_token,
+        refreshToken: newTokens.refresh_token,
+        expiresAt: Date.now() + newTokens.expires_in * 1000
+      };
     }
-    return this.authState.accessToken;
+    return this.tokens.accessToken;
   }
-  async chat(messages, options = {}) {
-    const token = await this.ensureAuth();
-    const chatMessages = typeof messages === "string" ? [{ role: "user", content: messages }] : messages;
-    const response = await fetch(`${API_BASE_URL}/chat/completions`, {
+  async request(endpoint, body) {
+    const token = await this.getValidToken();
+    const response = await fetch(`${API_BASE}${endpoint}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
       },
-      body: JSON.stringify({
-        model: options.model ?? this.model,
-        messages: chatMessages,
-        stream: false,
-        ...options
-      })
+      body: JSON.stringify(body)
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`Chat request failed: ${response.status} - ${error}`);
+      throw new Error(`Request failed: ${response.status} - ${error}`);
     }
-    return await response.json();
+    return response;
   }
-  async* chatStream(messages, options = {}) {
-    const token = await this.ensureAuth();
-    const chatMessages = typeof messages === "string" ? [{ role: "user", content: messages }] : messages;
-    const response = await fetch(`${API_BASE_URL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        model: options.model ?? this.model,
-        messages: chatMessages,
-        stream: true,
-        ...options
-      })
+  async chat(messages, options) {
+    const response = await this.request("/chat/completions", {
+      model: options?.model ?? this.model,
+      messages,
+      temperature: options?.temperature,
+      stream: false
+    });
+    return response.json();
+  }
+  async* chatStream(messages, options) {
+    const msgs = typeof messages === "string" ? [{ role: "user", content: messages }] : messages;
+    const response = await this.request("/chat/completions", {
+      model: options?.model ?? this.model,
+      messages: msgs,
+      temperature: options?.temperature,
+      stream: true
     });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Chat stream failed: ${response.status} - ${error}`);
-    }
     const reader = response.body?.getReader();
     if (!reader)
       throw new Error("No response body");
@@ -217,7 +212,7 @@ ${url}
           return;
         try {
           const chunk = JSON.parse(data);
-          const content = chunk.choices[0]?.delta?.content;
+          const content = chunk.choices?.[0]?.delta?.content;
           if (content)
             yield content;
         } catch {
@@ -226,19 +221,32 @@ ${url}
       }
     }
   }
-  async ask(prompt, options = {}) {
-    const response = await this.chat(prompt, options);
-    return response.choices[0]?.message?.content ?? "";
+  async ask(prompt, options) {
+    let result = "";
+    for await (const chunk of this.chatStream(prompt, options)) {
+      result += chunk;
+    }
+    return result;
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  getModel() {
+    return this.model;
   }
 }
 // src/index.ts
-function createQwen(options) {
-  return new QwenClient(options);
+function createQwen(config) {
+  return new QwenClient(config);
 }
 var src_default = QwenClient;
 export {
+  requestDeviceCode,
+  refreshAccessToken,
+  pollForToken,
+  isTokenExpired,
+  generatePKCE,
   src_default as default,
   createQwen,
-  QwenClient,
-  QwenAuth
+  QwenClient
 };

package/dist/types.d.ts

@@ -1,7 +1,16 @@
 export interface QwenConfig {
-    clientId?: string;
     accessToken?: string;
     refreshToken?: string;
+    model?: string;
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface ChatOptions {
+    model?: string;
+    temperature?: number;
+    stream?: boolean;
 }
 export interface DeviceCodeResponse {
     device_code: string;
@@ -17,50 +26,46 @@ export interface TokenResponse {
     token_type: string;
     expires_in: number;
 }
-export interface ChatMessage {
-    role: "system" | "user" | "assistant";
-    content: string;
-}
-export interface ChatRequest {
-    model?: string;
-    messages: ChatMessage[];
-    stream?: boolean;
-    temperature?: number;
-    max_tokens?: number;
+export interface TokenState {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
 }
-export interface ChatChoice {
-    index: number;
-    message: ChatMessage;
-    finish_reason: string;
+export interface PKCEPair {
+    verifier: string;
+    challenge: string;
 }
 export interface ChatResponse {
     id: string;
     object: string;
     created: number;
     model: string;
-    choices: ChatChoice[];
-    usage: {
+    choices: {
+        index: number;
+        message: ChatMessage;
+        finish_reason: string;
+    }[];
+    usage?: {
         prompt_tokens: number;
         completion_tokens: number;
         total_tokens: number;
     };
 }
 export interface StreamChunk {
-    id: string;
-    object: string;
-    created: number;
-    model: string;
-    choices: {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices?: {
         index: number;
         delta: {
-            content?: string;
             role?: string;
+            content?: string;
         };
-        finish_reason: string | null;
+        finish_reason?: string | null;
     }[];
 }
-export interface AuthState {
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: number;
+export interface ChatSession {
+    messages: ChatMessage[];
+    model: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwen.js",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Elegant TypeScript SDK for Qwen AI API with OAuth/PKCE authentication",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target node && bun run build:types",
-    "build:types": "tsc --project tsconfig.build.json"
+    "build:types": "tsc --project tsconfig.build.json",
+    "test": "bun test"
   },
   "keywords": [
     "qwen",

package/readme.md

@@ -1,18 +1,29 @@
+<div align="center">
+
+![Bun](https://img.shields.io/badge/-Bun-0D1117?style=flat-square&logo=Bun&logoColor=F3E6D8)
+![TypeScript](https://img.shields.io/badge/-TypeScript-0D1117?style=flat-square&logo=typescript&logoColor=3178C6)
+![License](https://img.shields.io/badge/license-MIT-0D1117?style=flat-square&logo=open-source-initiative&logoColor=green&labelColor=0D1117)
+
 # qwen.js
 
-Elegant TypeScript SDK for Qwen AI API with OAuth/PKCE authentication.
+Elegant TypeScript SDK for Qwen AI API
 
-## Installation
+</div>
 
-```bash
-# bun
-bun add qwen.js
+## About
+
+Simple and powerful wrapper for Qwen AI API with OAuth/PKCE authentication. Built with Bun/TypeScript, zero external dependencies.
+
+Features:
+- OAuth/PKCE device flow authentication
+- Automatic token refresh
+- Streaming responses
+- Simple `ask()` method for quick prompts
 
-# npm
-npm install qwen.js
+## Install
 
-# pnpm
-pnpm add qwen.js
+```bash
+bun add qwen.js
 ```
 
 ## Quick Start
@@ -22,10 +33,8 @@ import { createQwen } from "qwen.js"
 
 const qwen = createQwen()
 
-// Authenticate (opens browser for OAuth)
 await qwen.authenticate()
 
-// Simple chat
 const answer = await qwen.ask("What is quantum computing?")
 console.log(answer)
 ```
@@ -52,15 +61,12 @@ import { createQwen } from "qwen.js"
 
 const qwen = createQwen()
 
-// Get auth URL
 const { url, userCode } = await qwen.login()
 console.log(`Open: ${url}`)
 console.log(`Code: ${userCode}`)
 
-// Wait for user to authenticate
 await qwen.waitForAuth()
 
-// Now you can chat
 const answer = await qwen.ask("Hello!")
 ```
 
@@ -86,8 +92,6 @@ const qwen = createQwen({ accessToken: "..." })
 const response = await qwen.chat([
   { role: "system", content: "You are a helpful assistant" },
   { role: "user", content: "What is 2+2?" },
-  { role: "assistant", content: "4" },
-  { role: "user", content: "And 3+3?" },
 ])
 
 console.log(response.choices[0].message.content)
@@ -101,11 +105,9 @@ import { createQwen } from "qwen.js"
 const qwen = createQwen()
 await qwen.authenticate()
 
-// Save tokens for later
 const tokens = qwen.getTokens()
 await Bun.write("tokens.json", JSON.stringify(tokens))
 
-// Later: restore tokens
 const saved = await Bun.file("tokens.json").json()
 const qwen2 = createQwen({
   accessToken: saved.accessToken,
@@ -113,30 +115,38 @@ const qwen2 = createQwen({
 })
 ```
 
-## API Reference
+## API
 
 ### `createQwen(options?)`
 
-Creates a new Qwen client.
+| Option | Type | Description |
+|--------|------|-------------|
+| `accessToken` | `string` | Pre-existing access token |
+| `refreshToken` | `string` | Pre-existing refresh token |
+| `model` | `string` | Default model (default: `qwen-plus`) |
+
+### Methods
+
+| Method | Description |
+|--------|-------------|
+| `authenticate()` | Full OAuth flow with console prompts |
+| `login()` | Get device code and auth URL |
+| `waitForAuth()` | Poll for token after user authenticates |
+| `setTokens(accessToken, refreshToken?)` | Set tokens manually |
+| `getTokens()` | Get current auth state |
+| `ask(prompt, options?)` | Simple prompt, returns string |
+| `chat(messages, options?)` | Full chat, returns ChatResponse |
+| `chatStream(messages, options?)` | Streaming chat, yields chunks |
+| `setModel(model)` | Change default model |
 
-Options:
-- `accessToken` - Pre-existing access token
-- `refreshToken` - Pre-existing refresh token  
-- `model` - Default model (default: `qwen-plus`)
+## License
 
-### `QwenClient`
+MIT
 
-#### Methods
+<div align="center">
 
-- `authenticate()` - Full OAuth flow with console prompts
-- `login()` - Get device code and auth URL
-- `waitForAuth()` - Poll for token after user authenticates
-- `setTokens(accessToken, refreshToken?)` - Set tokens manually
-- `getTokens()` - Get current auth state
-- `ask(prompt, options?)` - Simple prompt, returns string
-- `chat(messages, options?)` - Full chat, returns ChatResponse
-- `chatStream(messages, options?)` - Streaming chat, yields chunks
+---
 
-## License
+Telegram: [zarazaex](https://t.me/zarazaexe) · [zarazaex.xyz](https://zarazaex.xyz)
 
-MIT
+</div>