qwen.js 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,14 @@
+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>;
+}

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+import type { ChatMessage, ChatRequest, ChatResponse, AuthState } from "./types";
+export declare class QwenClient {
+    private auth;
+    private authState;
+    private model;
+    constructor(options?: {
+        accessToken?: string;
+        refreshToken?: string;
+        model?: string;
+    });
+    login(): Promise<{
+        url: string;
+        userCode: string;
+    }>;
+    waitForAuth(): Promise<void>;
+    authenticate(): Promise<string>;
+    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>;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { QwenClient } from "./client";
+export { QwenAuth } from "./auth";
+export type { QwenConfig, ChatMessage, ChatRequest, ChatResponse, StreamChunk, AuthState, DeviceCodeResponse, TokenResponse, } from "./types";
+import { QwenClient } from "./client";
+export declare function createQwen(options?: {
+    accessToken?: string;
+    refreshToken?: string;
+    model?: string;
+}): QwenClient;
+export default QwenClient;

package/dist/index.js

@@ -0,0 +1,244 @@
+// 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() {
+  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 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, "");
+}
+
+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`, {
+      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"
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Device code request failed: ${response.status}`);
+    }
+    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");
+    }
+    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");
+    }
+    throw new Error("Authorization timeout");
+  }
+  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
+    };
+  }
+}
+
+// src/client.ts
+var API_BASE_URL = "https://portal.qwen.ai/v1";
+var DEFAULT_MODEL = "qwen-plus";
+
+class QwenClient {
+  auth;
+  authState = 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
+      };
+    }
+  }
+  async login() {
+    return this.auth.requestDeviceCode();
+  }
+  async waitForAuth() {
+    this.authState = await this.auth.pollForToken();
+  }
+  async authenticate() {
+    const { url, userCode } = await this.login();
+    console.log(`
+Open this URL to authenticate:
+${url}
+`);
+    console.log(`Your code: ${userCode}
+`);
+    await this.waitForAuth();
+    return this.authState.accessToken;
+  }
+  setTokens(accessToken, refreshToken) {
+    this.authState = {
+      accessToken,
+      refreshToken: refreshToken ?? "",
+      expiresAt: Date.now() + 6 * 60 * 60 * 1000
+    };
+  }
+  getTokens() {
+    return this.authState;
+  }
+  async ensureAuth() {
+    if (!this.authState) {
+      throw new Error("Not authenticated. Call login() and waitForAuth() first, or use setTokens()");
+    }
+    if (this.authState.refreshToken && Date.now() > this.authState.expiresAt - 5 * 60 * 1000) {
+      this.authState = await this.auth.refreshToken(this.authState.refreshToken);
+    }
+    return this.authState.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`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        model: options.model ?? this.model,
+        messages: chatMessages,
+        stream: false,
+        ...options
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Chat request failed: ${response.status} - ${error}`);
+    }
+    return await response.json();
+  }
+  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
+      })
+    });
+    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");
+    const decoder = new TextDecoder;
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: "))
+          continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]")
+          return;
+        try {
+          const chunk = JSON.parse(data);
+          const content = chunk.choices[0]?.delta?.content;
+          if (content)
+            yield content;
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  async ask(prompt, options = {}) {
+    const response = await this.chat(prompt, options);
+    return response.choices[0]?.message?.content ?? "";
+  }
+}
+// src/index.ts
+function createQwen(options) {
+  return new QwenClient(options);
+}
+var src_default = QwenClient;
+export {
+  src_default as default,
+  createQwen,
+  QwenClient,
+  QwenAuth
+};

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+export interface QwenConfig {
+    clientId?: string;
+    accessToken?: string;
+    refreshToken?: string;
+}
+export interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+}
+export interface TokenResponse {
+    access_token: string;
+    refresh_token: string;
+    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 ChatChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason: string;
+}
+export interface ChatResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: ChatChoice[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface StreamChunk {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: {
+            content?: string;
+            role?: string;
+        };
+        finish_reason: string | null;
+    }[];
+}
+export interface AuthState {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "qwen.js",
+  "version": "0.1.0",
+  "description": "Elegant TypeScript SDK for Qwen AI API with OAuth/PKCE authentication",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && bun run build:types",
+    "build:types": "tsc --project tsconfig.build.json"
+  },
+  "keywords": [
+    "qwen",
+    "ai",
+    "llm",
+    "chat",
+    "api",
+    "sdk",
+    "typescript",
+    "alibaba"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zarazaex/qwen.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zarazaex/qwen.js/issues"
+  },
+  "homepage": "https://github.com/zarazaex/qwen.js#readme",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  }
+}

package/readme.md

@@ -0,0 +1,142 @@
+# qwen.js
+
+Elegant TypeScript SDK for Qwen AI API with OAuth/PKCE authentication.
+
+## Installation
+
+```bash
+# bun
+bun add qwen.js
+
+# npm
+npm install qwen.js
+
+# pnpm
+pnpm add qwen.js
+```
+
+## Quick Start
+
+```typescript
+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)
+```
+
+## Usage
+
+### With Existing Tokens
+
+```typescript
+import { createQwen } from "qwen.js"
+
+const qwen = createQwen({
+  accessToken: "your-access-token",
+  refreshToken: "your-refresh-token",
+})
+
+const response = await qwen.ask("Hello!")
+```
+
+### Manual Authentication Flow
+
+```typescript
+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!")
+```
+
+### Streaming Responses
+
+```typescript
+import { createQwen } from "qwen.js"
+
+const qwen = createQwen({ accessToken: "..." })
+
+for await (const chunk of qwen.chatStream("Tell me a story")) {
+  process.stdout.write(chunk)
+}
+```
+
+### Full Chat with Message History
+
+```typescript
+import { createQwen } from "qwen.js"
+
+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)
+```
+
+### Save and Restore Tokens
+
+```typescript
+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,
+  refreshToken: saved.refreshToken,
+})
+```
+
+## API Reference
+
+### `createQwen(options?)`
+
+Creates a new Qwen client.
+
+Options:
+- `accessToken` - Pre-existing access token
+- `refreshToken` - Pre-existing refresh token  
+- `model` - Default model (default: `qwen-plus`)
+
+### `QwenClient`
+
+#### Methods
+
+- `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
+
+MIT