@oevortex/opencode-qwen-auth 0.1.0

package/src/qwen/thinking-parser.ts

@@ -0,0 +1,190 @@
+/**
+ * Thinking Block Parser for Qwen
+ * Handles <think>...</think> tags in the stream to separate
+ * reasoning content from regular text content.
+ *
+ * Based on revibe/core/llm/backend/qwen/handler.py
+ */
+
+export interface ParseResult {
+  /** Regular content (outside thinking blocks) */
+  regularContent: string;
+  /** Reasoning/thinking content (inside thinking blocks) */
+  reasoningContent: string;
+}
+
+/**
+ * Parser for Qwen's thinking/reasoning blocks.
+ *
+ * Handles `<think>...</think>` tags in the stream to separate
+ * reasoning content from regular text content.
+ *
+ * This parser is stateful and designed for streaming scenarios
+ * where tags might be split across multiple chunks.
+ */
+export class ThinkingBlockParser {
+  private inThinkingBlock = false;
+  private buffer = "";
+
+  /**
+   * Reset the parser state.
+   * Call this when starting a new message/response.
+   */
+  reset(): void {
+    this.inThinkingBlock = false;
+    this.buffer = "";
+  }
+
+  /**
+   * Check if currently inside a thinking block.
+   */
+  isInThinkingBlock(): boolean {
+    return this.inThinkingBlock;
+  }
+
+  /**
+   * Parse text and separate thinking content from regular content.
+   *
+   * This method is designed for streaming - call it with each chunk
+   * of text as it arrives, and it will return the parsed content.
+   *
+   * @param text - The text chunk to parse
+   * @returns Object containing regular and reasoning content
+   */
+  parse(text: string): ParseResult {
+    let regularContent = "";
+    let reasoningContent = "";
+
+    // Add to buffer and process
+    this.buffer += text;
+
+    while (true) {
+      if (this.inThinkingBlock) {
+        // Look for closing tag
+        const endIdx = this.buffer.indexOf("</think>");
+        if (endIdx !== -1) {
+          reasoningContent += this.buffer.slice(0, endIdx);
+          this.buffer = this.buffer.slice(endIdx + 8); // len("</think>") = 8
+          this.inThinkingBlock = false;
+        } else {
+          // Still in thinking block, emit all as reasoning
+          reasoningContent += this.buffer;
+          this.buffer = "";
+          break;
+        }
+      } else {
+        // Look for opening tag
+        const startIdx = this.buffer.indexOf("<think>");
+        if (startIdx !== -1) {
+          regularContent += this.buffer.slice(0, startIdx);
+          this.buffer = this.buffer.slice(startIdx + 7); // len("<think>") = 7
+          this.inThinkingBlock = true;
+        } else {
+          // Check for partial opening tag at the end of buffer
+          // This handles cases where "<think>" is split across chunks
+          const partialTag = this.findPartialOpenTag();
+          if (partialTag > 0) {
+            // Keep potential partial tag in buffer, emit the rest
+            regularContent += this.buffer.slice(0, -partialTag);
+            this.buffer = this.buffer.slice(-partialTag);
+          } else {
+            // No thinking block, emit all as regular content
+            regularContent += this.buffer;
+            this.buffer = "";
+          }
+          break;
+        }
+      }
+    }
+
+    return { regularContent, reasoningContent };
+  }
+
+  /**
+   * Find if there's a partial opening tag at the end of the buffer.
+   * Returns the length of the partial tag, or 0 if none found.
+   */
+  private findPartialOpenTag(): number {
+    const tag = "<think>";
+    for (let len = Math.min(tag.length - 1, this.buffer.length); len > 0; len--) {
+      const suffix = this.buffer.slice(-len);
+      if (tag.startsWith(suffix)) {
+        return len;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Flush any remaining content in the buffer.
+   * Call this when the stream is complete.
+   *
+   * @returns Any remaining content based on current state
+   */
+  flush(): ParseResult {
+    const result: ParseResult = {
+      regularContent: "",
+      reasoningContent: "",
+    };
+
+    if (this.buffer.length > 0) {
+      if (this.inThinkingBlock) {
+        result.reasoningContent = this.buffer;
+      } else {
+        result.regularContent = this.buffer;
+      }
+      this.buffer = "";
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Parse complete text for thinking blocks (non-streaming).
+ *
+ * Use this for non-streaming responses where the entire text is available.
+ *
+ * @param text - The complete text to parse
+ * @returns Object containing regular and reasoning content
+ */
+export function parseThinkingBlocks(text: string): ParseResult {
+  const parser = new ThinkingBlockParser();
+  const result = parser.parse(text);
+  const flushed = parser.flush();
+
+  return {
+    regularContent: result.regularContent + flushed.regularContent,
+    reasoningContent: result.reasoningContent + flushed.reasoningContent,
+  };
+}
+
+/**
+ * Remove thinking blocks from text, returning only regular content.
+ *
+ * @param text - The text to process
+ * @returns Text with thinking blocks removed
+ */
+export function stripThinkingBlocks(text: string): string {
+  return parseThinkingBlocks(text).regularContent;
+}
+
+/**
+ * Extract only thinking/reasoning content from text.
+ *
+ * @param text - The text to process
+ * @returns Only the content inside thinking blocks
+ */
+export function extractThinkingContent(text: string): string {
+  return parseThinkingBlocks(text).reasoningContent;
+}
+
+/**
+ * Check if text contains any thinking blocks.
+ *
+ * @param text - The text to check
+ * @returns True if text contains <think> tags
+ */
+export function hasThinkingBlocks(text: string): boolean {
+  return text.includes("<think>") || text.includes("</think>");
+}

package/src/types.ts

@@ -0,0 +1,292 @@
+/**
+ * Qwen OAuth and plugin types
+ * Based on revibe/core/llm/backend/qwen implementation
+ */
+
+// ============================================================
+// OAuth Types
+// ============================================================
+
+export interface QwenOAuthCredentials {
+  access_token: string;
+  refresh_token: string;
+  token_type: string;
+  expiry_date: number; // Timestamp in milliseconds
+  resource_url?: string;
+}
+
+export interface QwenTokenResponse {
+  access_token: string;
+  refresh_token?: string;
+  token_type: string;
+  expires_in: number; // Seconds until expiration
+  error?: string;
+  error_description?: string;
+}
+
+// ============================================================
+// Model Types
+// ============================================================
+
+export interface QwenModelInfo {
+  id: string;
+  name: string;
+  context_window?: number;
+  max_output?: number;
+  input_price?: number; // Per million tokens
+  output_price?: number; // Per million tokens
+  supports_native_tools?: boolean;
+  supports_thinking?: boolean;
+}
+
+// ============================================================
+// Stream Chunk Types
+// ============================================================
+
+export type StreamChunkType =
+  | "text"
+  | "reasoning"
+  | "thinking_complete"
+  | "usage"
+  | "tool_call"
+  | "tool_call_start"
+  | "tool_call_delta"
+  | "tool_call_end"
+  | "tool_call_partial"
+  | "error";
+
+export interface StreamTextChunk {
+  type: "text";
+  text: string;
+}
+
+export interface StreamReasoningChunk {
+  type: "reasoning";
+  text: string;
+  signature?: string;
+}
+
+export interface StreamUsageChunk {
+  type: "usage";
+  input_tokens: number;
+  output_tokens: number;
+  cache_write_tokens?: number;
+  cache_read_tokens?: number;
+  reasoning_tokens?: number;
+}
+
+export interface StreamToolCallPartialChunk {
+  type: "tool_call_partial";
+  index: number;
+  id?: string;
+  name?: string;
+  arguments?: string;
+}
+
+export interface StreamErrorChunk {
+  type: "error";
+  error: string;
+  message: string;
+}
+
+export type StreamChunk =
+  | StreamTextChunk
+  | StreamReasoningChunk
+  | StreamUsageChunk
+  | StreamToolCallPartialChunk
+  | StreamErrorChunk;
+
+// ============================================================
+// API Request/Response Types
+// ============================================================
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content?: string;
+  reasoning_content?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+  name?: string;
+}
+
+export interface ToolCall {
+  id?: string;
+  index?: number;
+  type?: "function";
+  function: FunctionCall;
+}
+
+export interface FunctionCall {
+  name?: string;
+  arguments?: string;
+}
+
+export interface Tool {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+
+export type ToolChoice = "none" | "auto" | "required" | { type: "function"; function: { name: string } };
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: ChatMessage[];
+  temperature?: number;
+  max_tokens?: number;
+  tools?: Tool[];
+  tool_choice?: ToolChoice;
+  stream?: boolean;
+  stream_options?: {
+    include_usage?: boolean;
+  };
+}
+
+export interface ChatCompletionChoice {
+  index: number;
+  message?: ChatMessage;
+  delta?: Partial<ChatMessage>;
+  finish_reason?: string | null;
+}
+
+export interface ChatCompletionUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens?: number;
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: ChatCompletionChoice[];
+  usage?: ChatCompletionUsage;
+  error?: {
+    message: string;
+    type?: string;
+    code?: string;
+  };
+}
+
+export interface ChatCompletionChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: ChatCompletionChoice[];
+  usage?: ChatCompletionUsage;
+  error?: {
+    message: string;
+    type?: string;
+    code?: string;
+  };
+}
+
+// ============================================================
+// Plugin Types
+// ============================================================
+
+export interface AuthDetails {
+  type: "oauth" | "api";
+}
+
+export interface OAuthAuthDetails extends AuthDetails {
+  type: "oauth";
+  access?: string;
+  refresh: string;
+  expires?: number;
+}
+
+export interface ApiAuthDetails extends AuthDetails {
+  type: "api";
+  apiKey: string;
+}
+
+export interface RefreshParts {
+  refreshToken: string;
+  resourceUrl?: string;
+}
+
+export interface LoaderResult {
+  apiKey?: string;
+  baseUrl?: string;
+  fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+
+export interface Provider {
+  models?: Record<string, { cost?: { input: number; output: number } } | undefined>;
+}
+
+export type GetAuth = () => Promise<AuthDetails>;
+
+export interface PluginContext {
+  client: {
+    auth: {
+      set: (options: { path: { id: string }; body: Record<string, unknown> }) => Promise<void>;
+    };
+    tui: {
+      showToast: (options: { body: { message: string; variant: "info" | "success" | "warning" | "error" } }) => Promise<void>;
+    };
+    log?: {
+      debug: (message: string, meta?: Record<string, unknown>) => void;
+      info: (message: string, meta?: Record<string, unknown>) => void;
+      warn: (message: string, meta?: Record<string, unknown>) => void;
+      error: (message: string, meta?: Record<string, unknown>) => void;
+    };
+  };
+}
+
+export interface AuthorizeResult {
+  url: string;
+  instructions?: string;
+  method: "auto" | "manual";
+  callback: () => Promise<TokenExchangeResult>;
+}
+
+export interface TokenExchangeResult {
+  type: "success" | "failed";
+  refresh?: string;
+  access?: string;
+  expires?: number;
+  error?: string;
+  resourceUrl?: string;
+}
+
+export interface AuthMethod {
+  label: string;
+  type: "oauth" | "api";
+  authorize?: () => Promise<AuthorizeResult>;
+  prompts?: Array<{
+    type: "text" | "password";
+    message: string;
+    key: string;
+  }>;
+}
+
+export interface PluginResult {
+  auth?: {
+    provider: string;
+    loader: (getAuth: GetAuth, provider: Provider) => Promise<LoaderResult | Record<string, unknown>>;
+    methods: AuthMethod[];
+  };
+  tool?: Record<string, unknown>;
+}
+
+// ============================================================
+// Rate Limit Types
+// ============================================================
+
+export interface RateLimitState {
+  consecutive429: number;
+  lastAt: number;
+}
+
+export interface RateLimitDelay {
+  attempt: number;
+  serverRetryAfterMs: number | null;
+  delayMs: number;
+}