@vybestack/llxprt-code-core 0.1.23 → 0.2.2-nightly.250908.7b895396

package/README.md

@@ -47,21 +47,6 @@ You have two options to install LLxprt Code.
    npx https://github.com/acoliver/llxprt-code
    ```
 
-### With Homebrew
-
-1. **Prerequisites:** Ensure you have [Homebrew](https://brew.sh/) installed.
-2. **Install the CLI:** Execute the following command in your terminal:
-
-   ```bash
-   brew install llxprt-code
-   ```
-
-   Then, run the CLI from anywhere:
-
-   ```bash
-   llxprt
-   ```
-
 ### Common Configuration Steps
 
 3. **Run and configure:**
@@ -127,10 +112,10 @@ Access Qwen3-Coder-Pro and other Qwen models for free:
 Use OAuth authentication to access Qwen with your free account:
 
 ```
-/auth qwen
+/auth qwen enable
 ```
 
-Your browser will open to the Qwen authentication page. Log in and authorize LLxprt Code, then copy the authorization code shown and paste it back in the terminal. You're now using Qwen3-Coder-Pro for free!
+This enables OAuth for Qwen. When you send your first message, your browser will automatically open to the Qwen authentication page. Log in and authorize LLxprt Code - the authentication will complete automatically and your request will be processed. You're now using Qwen3-Coder-Pro for free!
 
 #### Option 2: Use an API Key
 
@@ -144,6 +129,25 @@ For advanced users who need API access:
    /model qwen3-coder-pro
    ```
 
+### Using Cerebras Code Max/Pro
+
+Access Cerebras Code Max/Pro plan with the powerful qwen-3-coder-480b model:
+
+1. Get your API key from [Cerebras](https://cloud.cerebras.ai/)
+2. Configure LLxprt Code:
+   ```
+   /provider openai
+   /baseurl https://api.cerebras.ai/v1
+   /key your-cerebras-api-key
+   /model qwen-3-coder-480b
+   ```
+
+For optimal performance with this model, consider setting a high context limit:
+
+```
+/set context-limit 100000
+```
+
 ### Using Local Models
 
 Run models locally for complete privacy and control. LLxprt Code works with any OpenAI-compatible server.

package/dist/src/adapters/IStreamAdapter.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Vybestack LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { IMessage } from '../providers/IMessage.js';
+import { IContent } from '../services/history/IContent.js';
 import { ServerGeminiStreamEvent } from '../core/turn.js';
 /**
  * Interface for adapting provider-specific streams to Gemini event format
@@ -11,8 +11,8 @@ import { ServerGeminiStreamEvent } from '../core/turn.js';
 export interface IStreamAdapter {
     /**
      * Adapts a provider's stream format to Gemini's event stream format
-     * @param providerStream The provider-specific stream of messages
+     * @param providerStream The provider-specific stream of content
      * @returns An async iterator of Gemini events
      */
-    adaptStream(providerStream: AsyncIterableIterator<IMessage>): AsyncIterableIterator<ServerGeminiStreamEvent>;
+    adaptStream(providerStream: AsyncIterableIterator<IContent>): AsyncIterableIterator<ServerGeminiStreamEvent>;
 }

package/dist/src/auth/oauth-errors.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * OAuth Error Handling System
+ *
+ * Provides comprehensive error classification, user-friendly messaging,
+ * and recovery mechanisms for OAuth providers.
+ */
+/**
+ * OAuth error categories for classification and handling
+ */
+export declare enum OAuthErrorCategory {
+    /** User must take action (re-authenticate, grant permissions) */
+    USER_ACTION_REQUIRED = "user_action_required",
+    /** Network or temporary service issues that can be retried */
+    TRANSIENT = "transient",
+    /** System issues (file permissions, storage problems) */
+    SYSTEM = "system",
+    /** Critical security or data corruption issues */
+    CRITICAL = "critical",
+    /** Configuration or setup problems */
+    CONFIGURATION = "configuration"
+}
+/**
+ * Specific OAuth error types with detailed classification
+ */
+export declare enum OAuthErrorType {
+    AUTHENTICATION_REQUIRED = "authentication_required",
+    AUTHORIZATION_EXPIRED = "authorization_expired",
+    INSUFFICIENT_PERMISSIONS = "insufficient_permissions",
+    USER_CANCELLED = "user_cancelled",
+    INVALID_CREDENTIALS = "invalid_credentials",
+    NETWORK_ERROR = "network_error",
+    SERVICE_UNAVAILABLE = "service_unavailable",
+    RATE_LIMITED = "rate_limited",
+    TIMEOUT = "timeout",
+    STORAGE_ERROR = "storage_error",
+    FILE_PERMISSIONS = "file_permissions",
+    CORRUPTED_DATA = "corrupted_data",
+    SECURITY_VIOLATION = "security_violation",
+    MALFORMED_TOKEN = "malformed_token",
+    INVALID_CLIENT_ID = "invalid_client_id",
+    INVALID_ENDPOINT = "invalid_endpoint",
+    MISSING_CONFIGURATION = "missing_configuration",
+    UNKNOWN = "unknown"
+}
+/**
+ * Retry strategy configuration
+ */
+export interface RetryConfig {
+    /** Maximum number of retry attempts */
+    maxAttempts: number;
+    /** Base delay between retries in milliseconds */
+    baseDelayMs: number;
+    /** Multiplier for exponential backoff */
+    backoffMultiplier: number;
+    /** Maximum delay between retries in milliseconds */
+    maxDelayMs: number;
+    /** Whether to add random jitter to delays */
+    jitter: boolean;
+}
+/**
+ * Default retry configuration for transient errors
+ */
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/**
+ * Comprehensive OAuth error with classification and user guidance
+ */
+export declare class OAuthError extends Error {
+    readonly category: OAuthErrorCategory;
+    readonly type: OAuthErrorType;
+    readonly provider: string;
+    readonly userMessage: string;
+    readonly actionRequired: string | null;
+    readonly isRetryable: boolean;
+    readonly retryAfterMs: number | null;
+    readonly technicalDetails: Record<string, unknown>;
+    readonly originalError: Error | null;
+    constructor(type: OAuthErrorType, provider: string, message: string, options?: {
+        userMessage?: string;
+        actionRequired?: string;
+        retryAfterMs?: number;
+        technicalDetails?: Record<string, unknown>;
+        originalError?: Error;
+        cause?: Error;
+    });
+    /**
+     * Categorizes error type into handling categories
+     */
+    private categorizeError;
+    /**
+     * Determines if error type is retryable
+     */
+    private determineRetryability;
+    /**
+     * Generates user-friendly error message
+     */
+    private generateUserMessage;
+    /**
+     * Generates actionable guidance for users
+     */
+    private generateActionRequired;
+    /**
+     * Creates a sanitized version of the error for logging
+     */
+    toLogEntry(): Record<string, unknown>;
+}
+/**
+ * Error factory for common OAuth error scenarios
+ */
+export declare class OAuthErrorFactory {
+    /**
+     * Creates an authentication required error
+     */
+    static authenticationRequired(provider: string, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates an expired authorization error
+     */
+    static authorizationExpired(provider: string, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates a network error with retry capability
+     */
+    static networkError(provider: string, originalError?: Error, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates a rate limited error with specific retry delay
+     */
+    static rateLimited(provider: string, retryAfterSeconds?: number, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates a storage error
+     */
+    static storageError(provider: string, originalError?: Error, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates a corrupted data error
+     */
+    static corruptedData(provider: string, details?: Record<string, unknown>): OAuthError;
+    /**
+     * Creates an error from an unknown error, attempting classification
+     */
+    static fromUnknown(provider: string, error: unknown, context?: string): OAuthError;
+}
+/**
+ * Retry handler with exponential backoff and jitter
+ */
+export declare class RetryHandler {
+    private config;
+    constructor(config?: RetryConfig);
+    /**
+     * Executes operation with retry logic for transient errors
+     */
+    executeWithRetry<T>(operation: () => Promise<T>, provider: string, context?: string): Promise<T>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+/**
+ * Graceful error handler for OAuth operations
+ */
+export declare class GracefulErrorHandler {
+    private retryHandler;
+    constructor(retryHandler?: RetryHandler);
+    /**
+     * Handles errors gracefully, providing fallback behavior when possible
+     */
+    handleGracefully<T>(operation: () => Promise<T>, fallback: T | (() => T | Promise<T>), provider: string, context?: string): Promise<T>;
+    /**
+     * Wraps a method to handle errors gracefully with logging
+     */
+    wrapMethod<TArgs extends unknown[], TReturn>(method: (...args: TArgs) => Promise<TReturn>, provider: string, methodName: string, fallback?: TReturn | ((...args: TArgs) => TReturn | Promise<TReturn>)): (...args: TArgs) => Promise<TReturn>;
+}