@vybestack/llxprt-ui 0.7.0-nightly.251211.5750c518a

package/src/features/config/configSession.ts

@@ -0,0 +1,179 @@
+import {
+  Config,
+  AuthType,
+  ProviderManager,
+  OpenAIProvider,
+  AnthropicProvider,
+  SettingsService,
+  registerSettingsService,
+  resetSettingsService,
+} from '@vybestack/llxprt-code-core';
+import type {
+  GeminiClient,
+  ConfigParameters,
+} from '@vybestack/llxprt-code-core';
+
+export interface ConfigSessionOptions {
+  readonly model: string;
+  readonly workingDir: string;
+  readonly provider?: string;
+  readonly baseUrl?: string;
+  readonly authKeyfile?: string;
+  readonly apiKey?: string;
+  readonly debugMode?: boolean;
+}
+
+export interface ConfigSession {
+  readonly config: Config;
+  initialize(): Promise<void>;
+  getClient(): GeminiClient;
+  dispose(): void;
+}
+
+/**
+ * Create the appropriate provider instance based on provider name.
+ */
+function createProvider(
+  providerName: string,
+  apiKey: string | undefined,
+  baseUrl: string | undefined,
+): OpenAIProvider | AnthropicProvider | null {
+  const name = providerName.toLowerCase();
+
+  if (name === 'openai' || name === 'openai-responses') {
+    return new OpenAIProvider(apiKey, baseUrl);
+  }
+  if (name === 'anthropic') {
+    return new AnthropicProvider(apiKey, baseUrl);
+  }
+
+  // Unknown provider - return null and fall back to Gemini
+  return null;
+}
+
+/**
+ * Check if a provider requires a ProviderManager (non-Gemini providers).
+ */
+function requiresProviderManager(providerName: string | undefined): boolean {
+  if (!providerName) return false;
+  const name = providerName.toLowerCase();
+  return (
+    name === 'openai' || name === 'openai-responses' || name === 'anthropic'
+  );
+}
+
+export function createConfigSession(
+  options: ConfigSessionOptions,
+): ConfigSession {
+  // Reset any existing context and create a fresh SettingsService
+  resetSettingsService();
+  const settings = new SettingsService();
+  registerSettingsService(settings);
+
+  // CRITICAL: Set model in SettingsService - providers read from here, not from Config
+  settings.set('model', options.model);
+
+  if (options.baseUrl) {
+    settings.set('base-url', options.baseUrl);
+  }
+  if (options.authKeyfile) {
+    settings.set('auth-keyfile', options.authKeyfile);
+  }
+  if (options.apiKey) {
+    settings.set('auth-key', options.apiKey);
+  }
+  if (options.provider) {
+    settings.set('activeProvider', options.provider);
+  }
+
+  const timestamp = Date.now();
+  const configParams = {
+    sessionId: `nui-${timestamp}`,
+    targetDir: options.workingDir,
+    cwd: options.workingDir,
+    debugMode: options.debugMode ?? false,
+    model: options.model,
+    provider: options.provider,
+    settingsService: settings,
+    telemetry: { enabled: false },
+    checkpointing: false,
+    // Use default llxprt-code policy behavior:
+    // - Read-only tools (read_file, glob, etc.) are auto-approved
+    // - Write tools (edit, shell, write_file) require confirmation
+    // The default TOML policies handle this via priority-based rules
+    policyEngineConfig: {
+      defaultDecision: 'ask_user' as const,
+    },
+  } as ConfigParameters;
+
+  const config = new Config(configParams);
+
+  let initialized = false;
+  let client: GeminiClient | undefined;
+
+  return {
+    config,
+
+    async initialize(): Promise<void> {
+      if (initialized) {
+        return;
+      }
+      await config.initialize();
+
+      const providerName = options.provider?.toLowerCase();
+
+      // For non-Gemini providers, set up ProviderManager first
+      if (requiresProviderManager(options.provider)) {
+        const provider = createProvider(
+          options.provider ?? '',
+          options.apiKey,
+          options.baseUrl,
+        );
+
+        if (provider) {
+          const providerManager = new ProviderManager();
+          providerManager.setConfig(config);
+          providerManager.registerProvider(provider);
+          providerManager.setActiveProvider(provider.name);
+          config.setProviderManager(providerManager);
+        }
+      }
+
+      // Determine auth type based on provider
+      let authType: AuthType;
+
+      if (providerName === 'gemini' || !providerName) {
+        // For Gemini: use API key auth if available, otherwise vertex AI for keyfile
+        if (options.apiKey) {
+          authType = AuthType.USE_GEMINI;
+        } else if (options.authKeyfile) {
+          authType = AuthType.USE_VERTEX_AI;
+        } else {
+          authType = AuthType.USE_GEMINI;
+        }
+      } else {
+        // For other providers: use provider-managed auth (requires ProviderManager)
+        authType = AuthType.USE_PROVIDER;
+      }
+
+      await config.refreshAuth(authType);
+      client = config.getGeminiClient();
+      initialized = true;
+    },
+
+    getClient(): GeminiClient {
+      if (!client) {
+        throw new Error(
+          'ConfigSession not initialized. Call initialize() first.',
+        );
+      }
+      return client;
+    },
+
+    dispose(): void {
+      initialized = false;
+      client = undefined;
+      resetSettingsService();
+    },
+  };
+}

package/src/features/config/index.ts

@@ -0,0 +1,4 @@
+export * from './llxprtConfig';
+export * from './llxprtAdapter';
+export * from './llxprtCommands';
+export * from './configSession';

package/src/features/config/llxprtAdapter.integration.test.ts

@@ -0,0 +1,202 @@
+/**
+ * @vitest-environment node
+ *
+ * End-to-end integration tests for the llxprt adapter.
+ * These tests actually send messages to real providers and verify responses.
+ * They require a valid synthetic profile to be configured.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createConfigSession, type ConfigSession } from './configSession';
+import { sendMessageWithSession, type AdapterEvent } from './llxprtAdapter';
+
+const SYNTHETIC_PROFILE_PATH = path.join(
+  os.homedir(),
+  '.llxprt/profiles/synthetic.json',
+);
+
+interface ProfileData {
+  provider?: string;
+  model?: string;
+  baseUrl?: string;
+  authKeyfile?: string;
+  ephemeralSettings?: Record<string, unknown>;
+}
+
+function loadSyntheticProfile(): ProfileData | null {
+  if (!existsSync(SYNTHETIC_PROFILE_PATH)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync(SYNTHETIC_PROFILE_PATH, 'utf8'),
+    ) as ProfileData;
+  } catch {
+    return null;
+  }
+}
+
+function readApiKey(keyfilePath: string): string | undefined {
+  try {
+    return readFileSync(keyfilePath, 'utf8').trim();
+  } catch {
+    return undefined;
+  }
+}
+
+function createSessionFromProfile(profile: ProfileData): ConfigSession | null {
+  const ephemeral = profile.ephemeralSettings ?? {};
+  const provider = profile.provider;
+  const baseUrl = (ephemeral['base-url'] ??
+    ephemeral.baseUrl ??
+    profile.baseUrl) as string | undefined;
+  const keyFilePath = (ephemeral['auth-keyfile'] ??
+    ephemeral.authKeyfile ??
+    profile.authKeyfile) as string | undefined;
+  const model = (ephemeral.model ?? profile.model) as string | undefined;
+
+  if (!provider || !baseUrl || !model) {
+    return null;
+  }
+
+  // Read the API key from keyfile if provided
+  const apiKey = keyFilePath ? readApiKey(keyFilePath) : undefined;
+  if (keyFilePath && !apiKey) {
+    return null; // Keyfile specified but couldn't read it
+  }
+
+  return createConfigSession({
+    model,
+    provider,
+    baseUrl,
+    apiKey,
+    workingDir: process.cwd(),
+  });
+}
+
+const syntheticProfile = loadSyntheticProfile();
+const describeSynthetic = syntheticProfile ? describe : describe.skip;
+
+describe('llxprtAdapter end-to-end', () => {
+  describeSynthetic('with synthetic profile', () => {
+    /**
+     * This is the CRITICAL end-to-end test that verifies the complete flow:
+     * 1. Create ConfigSession from profile
+     * 2. Initialize session (sets up auth, ProviderManager if needed)
+     * 3. Send a message via sendMessageWithSession
+     * 4. Receive streaming events
+     * 5. Verify we get actual text content
+     *
+     * This test would catch:
+     * - AuthType configuration errors
+     * - ProviderManager setup issues
+     * - Authorization header format issues
+     * - API key reading issues
+     * - Any HTTP/streaming issues
+     */
+    it('sends a message and receives streaming response', async () => {
+      const session = createSessionFromProfile(syntheticProfile!);
+      expect(session).not.toBeNull();
+
+      // Initialize the session - this is where auth errors would surface
+      await session!.initialize();
+
+      const events: AdapterEvent[] = [];
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 45000);
+
+      try {
+        for await (const event of sendMessageWithSession(
+          session!,
+          'Say exactly: Hello from integration test',
+          controller.signal,
+        )) {
+          events.push(event);
+
+          // Stop after getting some text to avoid running up API costs
+          const textDeltaCount = events.filter(
+            (e) => e.type === 'text_delta',
+          ).length;
+          if (textDeltaCount >= 3) {
+            controller.abort();
+            break;
+          }
+        }
+      } catch (error) {
+        // AbortError is expected when we manually abort
+        if (error instanceof Error && error.name !== 'AbortError') {
+          throw error;
+        }
+      } finally {
+        clearTimeout(timeout);
+        session!.dispose();
+      }
+
+      // Verify we got text events
+      const textDeltas = events.filter(
+        (e): e is Extract<AdapterEvent, { type: 'text_delta' }> =>
+          e.type === 'text_delta',
+      );
+      expect(textDeltas.length).toBeGreaterThan(0);
+
+      // Verify the combined text is non-empty
+      const combinedText = textDeltas.map((e) => e.text).join('');
+      expect(combinedText.length).toBeGreaterThan(0);
+    }, 60000);
+
+    /**
+     * Test that session initialization works without sending a message.
+     * This catches auth setup issues faster than the full message test.
+     */
+    it('initializes session successfully', async () => {
+      const session = createSessionFromProfile(syntheticProfile!);
+      expect(session).not.toBeNull();
+
+      // This should NOT throw any errors
+      await session!.initialize();
+
+      // Client should be available
+      const client = session!.getClient();
+      expect(client).toBeDefined();
+
+      session!.dispose();
+    }, 30000);
+
+    /**
+     * Test that tools are registered after initialization.
+     */
+    it('has tools registered after initialization', async () => {
+      const session = createSessionFromProfile(syntheticProfile!);
+      expect(session).not.toBeNull();
+
+      await session!.initialize();
+
+      const registry = session!.config.getToolRegistry();
+      const tools = registry.getFunctionDeclarations();
+      expect(tools.length).toBeGreaterThan(0);
+
+      session!.dispose();
+    }, 30000);
+
+    /**
+     * Test that model is correctly propagated through Config.
+     */
+    it('uses correct model from profile', async () => {
+      const session = createSessionFromProfile(syntheticProfile!);
+      expect(session).not.toBeNull();
+
+      // Check model before and after initialization
+      const modelBeforeInit = session!.config.getModel();
+      expect(modelBeforeInit).toBe(syntheticProfile!.model);
+
+      await session!.initialize();
+
+      const modelAfterInit = session!.config.getModel();
+      expect(modelAfterInit).toBe(syntheticProfile!.model);
+
+      session!.dispose();
+    }, 30000);
+  });
+});

package/src/features/config/llxprtAdapter.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { transformEvent, transformStream } from './llxprtAdapter';
+import {
+  GeminiEventType,
+  type ServerGeminiContentEvent,
+  type ServerGeminiThoughtEvent,
+  type ServerGeminiToolCallRequestEvent,
+  type ServerGeminiFinishedEvent,
+  type ServerGeminiErrorEvent,
+  type ServerGeminiStreamEvent,
+} from '@vybestack/llxprt-code-core';
+import { FinishReason } from '@google/genai';
+import type { AdapterEvent } from '../../types/events';
+
+describe('transformEvent', () => {
+  it('should convert Content event to text_delta', () => {
+    const input: ServerGeminiContentEvent = {
+      type: GeminiEventType.Content,
+      value: 'hello world',
+    };
+    const result = transformEvent(input);
+    expect(result).toStrictEqual({ type: 'text_delta', text: 'hello world' });
+  });
+
+  it('should convert Thought event to thinking_delta', () => {
+    const input: ServerGeminiThoughtEvent = {
+      type: GeminiEventType.Thought,
+      value: { subject: 'analysis', description: 'thinking about the problem' },
+    };
+    const result = transformEvent(input);
+    expect(result).toStrictEqual({
+      type: 'thinking_delta',
+      text: 'thinking about the problem',
+    });
+  });
+
+  it('should convert ToolCallRequest to tool_pending', () => {
+    const input: ServerGeminiToolCallRequestEvent = {
+      type: GeminiEventType.ToolCallRequest,
+      value: {
+        callId: 'call_123',
+        name: 'read_file',
+        args: { path: '/foo/bar.txt' },
+        isClientInitiated: false,
+        prompt_id: 'prompt_456',
+      },
+    };
+    const result = transformEvent(input);
+    expect(result).toStrictEqual({
+      type: 'tool_pending',
+      id: 'call_123',
+      name: 'read_file',
+      params: { path: '/foo/bar.txt' },
+    });
+  });
+
+  it('should convert Finished to complete', () => {
+    const input: ServerGeminiFinishedEvent = {
+      type: GeminiEventType.Finished,
+      value: { reason: FinishReason.STOP },
+    };
+    const result = transformEvent(input);
+    expect(result).toStrictEqual({ type: 'complete' });
+  });
+
+  it('should convert Error to error event', () => {
+    const input: ServerGeminiErrorEvent = {
+      type: GeminiEventType.Error,
+      value: { error: { message: 'something broke', status: 500 } },
+    };
+    const result = transformEvent(input);
+    expect(result).toStrictEqual({ type: 'error', message: 'something broke' });
+  });
+
+  it('should handle unknown event type with fallback', () => {
+    const input = {
+      type: 'unknown_type' as GeminiEventType,
+      value: { foo: 'bar' },
+    } as unknown as ServerGeminiStreamEvent;
+    const result = transformEvent(input);
+    expect(result.type).toBe('unknown');
+    expect(result).toHaveProperty('raw');
+  });
+});
+
+describe('transformStream', () => {
+  it('should yield transformed events from async iterable', async () => {
+    const mockEvents: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Content,
+        value: 'Hello',
+      } as ServerGeminiStreamEvent,
+      {
+        type: GeminiEventType.Content,
+        value: ' world',
+      } as ServerGeminiStreamEvent,
+      {
+        type: GeminiEventType.Finished,
+        value: { reason: FinishReason.STOP },
+      } as ServerGeminiStreamEvent,
+    ];
+
+    async function* mockStream(): AsyncGenerator<ServerGeminiStreamEvent> {
+      for (const event of mockEvents) {
+        yield await Promise.resolve(event);
+      }
+    }
+
+    const results: AdapterEvent[] = [];
+    for await (const event of transformStream(mockStream())) {
+      results.push(event);
+    }
+
+    expect(results).toHaveLength(3);
+    expect(results[0]).toStrictEqual({ type: 'text_delta', text: 'Hello' });
+    expect(results[1]).toStrictEqual({ type: 'text_delta', text: ' world' });
+    expect(results[2]).toStrictEqual({ type: 'complete' });
+  });
+
+  it('should handle empty stream', async () => {
+    const createEmptyStream = (
+      events: ServerGeminiStreamEvent[],
+    ): AsyncGenerator<ServerGeminiStreamEvent> => {
+      async function* generator(): AsyncGenerator<ServerGeminiStreamEvent> {
+        for (const event of events) {
+          yield await Promise.resolve(event);
+        }
+      }
+      return generator();
+    };
+
+    const results: AdapterEvent[] = [];
+    for await (const event of transformStream(createEmptyStream([]))) {
+      results.push(event);
+    }
+
+    expect(results).toHaveLength(0);
+  });
+});