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

package/src/features/config/llxprtAdapter.ts

@@ -0,0 +1,257 @@
+import {
+  GeminiEventType,
+  type ServerGeminiStreamEvent,
+  type ToolCallResponseInfo,
+  type ServerToolCallConfirmationDetails,
+} from '@vybestack/llxprt-code-core';
+import { getLogger } from '../../lib/logger';
+import type { AdapterEvent, ToolConfirmationType } from '../../types/events';
+import type { ConfigSession } from './configSession';
+import { createConfigSession } from './configSession';
+
+export type {
+  AdapterEvent,
+  ToolPendingEvent,
+  ToolConfirmationEvent,
+} from '../../types/events';
+
+/** Branded type for provider identifiers */
+export type ProviderKey = string & { readonly __brand?: 'ProviderKey' };
+
+export interface ProviderInfo {
+  readonly id: ProviderKey;
+  readonly label: string;
+}
+
+export interface ModelInfo {
+  readonly id: string;
+  readonly name: string;
+}
+
+export interface SessionConfig {
+  readonly provider: ProviderKey;
+  readonly model?: string;
+  readonly apiKey?: string;
+  readonly keyFilePath?: string;
+  readonly baseUrl?: string;
+  readonly ephemeralSettings?: Record<string, unknown>;
+}
+
+const logger = getLogger('nui:llxprt-adapter');
+
+/**
+ * Extract display output from a tool result
+ */
+function getToolResultOutput(info: ToolCallResponseInfo): string {
+  if (info.error) {
+    return info.error.message;
+  }
+  if (info.resultDisplay === undefined) {
+    return '(no output)';
+  }
+  if (typeof info.resultDisplay === 'string') {
+    return info.resultDisplay;
+  }
+  // FileDiff object - format as diff
+  const diff = info.resultDisplay;
+  return `File: ${diff.fileName}\n${diff.fileDiff}`;
+}
+
+/**
+ * Map confirmation details type to our simplified type
+ */
+function getConfirmationType(
+  details: ServerToolCallConfirmationDetails,
+): ToolConfirmationType {
+  const type = details.details.type as string;
+  if (type === 'edit') return 'edit';
+  if (type === 'exec') return 'exec';
+  if (type === 'mcp') return 'mcp';
+  if (type === 'info') return 'info';
+  return 'exec'; // fallback for unknown types
+}
+
+/**
+ * Get the preview content for a confirmation dialog
+ */
+function getConfirmationPreview(
+  details: ServerToolCallConfirmationDetails,
+): string {
+  const d = details.details;
+  const type = d.type as string;
+  if (type === 'edit' && 'fileDiff' in d) {
+    return d.fileDiff || `Edit: ${d.filePath}`;
+  }
+  if (type === 'exec' && 'command' in d) {
+    return d.command;
+  }
+  if (type === 'mcp' && 'toolDisplayName' in d) {
+    return `MCP Tool: ${d.toolDisplayName} (server: ${d.serverName})`;
+  }
+  if (type === 'info' && 'prompt' in d) {
+    const urls =
+      'urls' in d && Array.isArray(d.urls) && d.urls.length > 0
+        ? `\nURLs: ${d.urls.join(', ')}`
+        : '';
+    return d.prompt + urls;
+  }
+  return '';
+}
+
+/**
+ * Get the question text for a confirmation dialog
+ */
+function getConfirmationQuestion(
+  details: ServerToolCallConfirmationDetails,
+): string {
+  const d = details.details;
+  const type = d.type as string;
+  if (type === 'edit') {
+    return 'Apply this change?';
+  }
+  if (type === 'exec' && 'rootCommand' in d) {
+    return `Allow execution of: '${d.rootCommand}'?`;
+  }
+  if (type === 'mcp' && 'toolDisplayName' in d) {
+    return `Allow ${d.toolDisplayName}?`;
+  }
+  if (type === 'info') {
+    return 'Allow this fetch?';
+  }
+  return 'Allow this action?';
+}
+
+export function transformEvent(event: ServerGeminiStreamEvent): AdapterEvent {
+  if (event.type === GeminiEventType.Content) {
+    return { type: 'text_delta', text: event.value };
+  }
+  if (event.type === GeminiEventType.Thought) {
+    return { type: 'thinking_delta', text: event.value.description };
+  }
+  if (event.type === GeminiEventType.ToolCallRequest) {
+    return {
+      type: 'tool_pending',
+      id: event.value.callId,
+      name: event.value.name,
+      params: event.value.args,
+    };
+  }
+  if (event.type === GeminiEventType.ToolCallResponse) {
+    const info = event.value;
+    return {
+      type: 'tool_result',
+      id: info.callId,
+      success: !info.error,
+      output: getToolResultOutput(info),
+      errorMessage: info.error?.message,
+    };
+  }
+  if (event.type === GeminiEventType.ToolCallConfirmation) {
+    const details = event.value;
+    // Extract correlationId from the details object
+    const correlationId =
+      (details.details as { correlationId?: string }).correlationId ??
+      details.request.callId;
+    return {
+      type: 'tool_confirmation',
+      id: details.request.callId,
+      name: details.request.name,
+      params: details.request.args,
+      confirmationType: getConfirmationType(details),
+      question: getConfirmationQuestion(details),
+      preview: getConfirmationPreview(details),
+      canAllowAlways: true, // Will be determined by trusted folder status in future
+      correlationId,
+    };
+  }
+  if (event.type === GeminiEventType.UserCancelled) {
+    // This is a general cancellation, not tied to a specific tool
+    return { type: 'complete' };
+  }
+  if (event.type === GeminiEventType.Finished) {
+    return { type: 'complete' };
+  }
+  if (event.type === GeminiEventType.Error) {
+    return { type: 'error', message: event.value.error.message };
+  }
+  logger.warn('Unhandled event type received', { eventType: event.type });
+  return { type: 'unknown', raw: event };
+}
+
+export async function* transformStream(
+  stream: AsyncIterable<ServerGeminiStreamEvent>,
+): AsyncGenerator<AdapterEvent> {
+  for await (const event of stream) {
+    yield transformEvent(event);
+  }
+}
+
+export async function* sendMessageWithSession(
+  session: ConfigSession,
+  prompt: string,
+  signal?: AbortSignal,
+): AsyncGenerator<AdapterEvent> {
+  const client = session.getClient();
+  const promptId = `nui-prompt-${Date.now()}`;
+  const stream = client.sendMessageStream(
+    prompt,
+    signal ?? new AbortController().signal,
+    promptId,
+  );
+
+  for await (const event of stream) {
+    yield transformEvent(event);
+  }
+}
+
+const PROVIDER_ENTRIES: ProviderInfo[] = [
+  { id: 'openai', label: 'OpenAI' },
+  { id: 'openai-responses', label: 'OpenAI Responses' },
+  { id: 'openai-vercel', label: 'OpenAI (Vercel)' },
+  { id: 'gemini', label: 'Gemini' },
+  { id: 'anthropic', label: 'Anthropic' },
+  { id: 'synthetic', label: 'Synthetic' },
+  { id: 'qwen', label: 'Qwen' },
+  { id: 'qwen-openai', label: 'Qwen (OpenAI API)' },
+];
+
+export function listProviders(): ProviderInfo[] {
+  // Deduplicate by id in case we add aliases dynamically later
+  const seen = new Set<string>();
+  return PROVIDER_ENTRIES.filter((entry) => {
+    if (seen.has(entry.id)) {
+      return false;
+    }
+    seen.add(entry.id);
+    return true;
+  });
+}
+
+export async function listModels(session: SessionConfig): Promise<ModelInfo[]> {
+  // Model listing not currently implemented.
+  // ConfigSession doesn't expose getProvider() directly.
+  // Future implementation should use ConfigSession.config.getProviderManager()
+  logger.debug('listModels called but not implemented', {
+    provider: session.provider,
+  });
+  return Promise.resolve([]);
+}
+
+export async function* sendMessage(
+  sessionConfig: SessionConfig,
+  prompt: string,
+  signal?: AbortSignal,
+): AsyncGenerator<AdapterEvent> {
+  const session = createConfigSession({
+    model: sessionConfig.model ?? 'gemini-2.5-flash',
+    workingDir: process.cwd(),
+    provider: sessionConfig.provider,
+    baseUrl: sessionConfig.baseUrl,
+    authKeyfile: sessionConfig.keyFilePath,
+    apiKey: sessionConfig.apiKey,
+  });
+
+  await session.initialize();
+
+  yield* sendMessageWithSession(session, prompt, signal);
+}

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

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { SessionConfig } from './llxprtAdapter';
+import { handleModelListCommand } from './llxprtCommands';
+
+const BASE: SessionConfig = {
+  provider: 'openai',
+  baseUrl: 'https://example.test/api',
+  keyFilePath: path.join(os.tmpdir(), 'nui-test-key'),
+  model: 'dummy',
+};
+
+describe('handleModelListCommand', () => {
+  it('returns missing config messages when incomplete', async () => {
+    const result = await handleModelListCommand({ provider: 'openai' });
+    expect(result.handled).toBe(true);
+    expect(
+      result.messages.some((m) => m.toLowerCase().includes('base url')),
+    ).toBe(true);
+  });
+
+  it('lists models from provider', async () => {
+    const listModelsImpl = vi.fn().mockResolvedValue([
+      { id: 'm1', name: 'Model One' },
+      { id: 'm2', name: 'Model Two' },
+    ]);
+    const result = await handleModelListCommand(BASE, { listModelsImpl });
+    expect(listModelsImpl).toHaveBeenCalledOnce();
+    expect(result.messages[0]).toContain('Available models');
+    expect(result.messages.some((line) => line.includes('m1'))).toBe(true);
+    expect(result.messages.some((line) => line.includes('m2'))).toBe(true);
+  });
+
+  it('handles provider errors', async () => {
+    const listModelsImpl = vi.fn().mockRejectedValue(new Error('boom'));
+    const result = await handleModelListCommand(BASE, { listModelsImpl });
+    expect(result.messages[0]).toContain('Failed to list models');
+  });
+});

package/src/features/config/llxprtCommands.ts

@@ -0,0 +1,35 @@
+import type { SessionConfig } from './llxprtAdapter';
+import { listModels, type ModelInfo } from './llxprtAdapter';
+import { validateSessionConfig } from './llxprtConfig';
+
+export interface CommandOutcome {
+  readonly handled: boolean;
+  readonly messages: string[];
+}
+
+export async function handleModelListCommand(
+  session: SessionConfig,
+  deps?: { listModelsImpl?: (session: SessionConfig) => Promise<ModelInfo[]> },
+): Promise<CommandOutcome> {
+  const missing = validateSessionConfig(session, { requireModel: false });
+  if (missing.length > 0) {
+    return { handled: true, messages: missing };
+  }
+  const getModels = deps?.listModelsImpl ?? listModels;
+  try {
+    const models = await getModels(session);
+    if (models.length === 0) {
+      return { handled: true, messages: ['No models returned by provider.'] };
+    }
+    const lines = ['Available models:'].concat(
+      models.map((model) => {
+        const namePart = model.name ? ` (${model.name})` : '';
+        return `- ${model.id}${namePart}`;
+      }),
+    );
+    return { handled: true, messages: lines };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { handled: true, messages: [`Failed to list models: ${message}`] };
+  }
+}

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

@@ -0,0 +1,261 @@
+import { describe, expect, it } from 'vitest';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  applyConfigCommand,
+  validateSessionConfig,
+  profileToConfigOptions,
+} from './llxprtConfig';
+import type { SessionConfig } from './llxprtAdapter';
+import type { ProfileData } from './llxprtConfig';
+import type { Profile } from '@vybestack/llxprt-code-core';
+
+const BASE_CONFIG: SessionConfig = { provider: 'openai' };
+
+describe('applyConfigCommand', () => {
+  it('sets provider when valid', async () => {
+    const result = await applyConfigCommand('/provider gemini', BASE_CONFIG);
+    expect(result.handled).toBe(true);
+    expect(result.nextConfig.provider).toBe('gemini');
+    expect(result.messages[0]).toContain('Provider set to gemini');
+  });
+
+  it('defers empty provider to caller', async () => {
+    const result = await applyConfigCommand('/provider', BASE_CONFIG);
+    expect(result.handled).toBe(false);
+    expect(result.nextConfig).toStrictEqual(BASE_CONFIG);
+  });
+
+  it('rejects unknown provider', async () => {
+    const result = await applyConfigCommand('/provider something', BASE_CONFIG);
+    expect(result.handled).toBe(true);
+    expect(result.nextConfig.provider).toBe('openai');
+    expect(result.messages[0]).toContain('Unknown provider');
+  });
+
+  it('sets base url and accepts alias', async () => {
+    const result = await applyConfigCommand(
+      '/basurl https://example.test/api',
+      BASE_CONFIG,
+    );
+    expect(result.handled).toBe(true);
+    expect(result.nextConfig.baseUrl).toBe('https://example.test/api');
+  });
+
+  it('sets key and clears keyfile', async () => {
+    const result = await applyConfigCommand('/key secret', {
+      ...BASE_CONFIG,
+      keyFilePath: path.join(os.tmpdir(), 'nui-test-key'),
+    });
+    expect(result.nextConfig.apiKey).toBe('secret');
+    expect(result.nextConfig.keyFilePath).toBeUndefined();
+  });
+
+  it('sets keyfile and clears key', async () => {
+    const testKeyPath = path.join(os.tmpdir(), 'nui-test-keyfile');
+    const result = await applyConfigCommand(`/keyfile ${testKeyPath}`, {
+      ...BASE_CONFIG,
+      apiKey: 'old',
+    });
+    expect(result.nextConfig.keyFilePath).toBe(testKeyPath);
+    expect(result.nextConfig.apiKey).toBeUndefined();
+  });
+
+  it('sets model', async () => {
+    const result = await applyConfigCommand('/model hf:test', BASE_CONFIG);
+    expect(result.nextConfig.model).toBe('hf:test');
+  });
+
+  it('defers empty model to caller', async () => {
+    const result = await applyConfigCommand('/model', BASE_CONFIG);
+    expect(result.handled).toBe(false);
+    expect(result.nextConfig).toStrictEqual(BASE_CONFIG);
+  });
+
+  it('ignores unknown command', async () => {
+    const result = await applyConfigCommand('/unknown foo', BASE_CONFIG);
+    expect(result.handled).toBe(false);
+    expect(result.nextConfig).toStrictEqual(BASE_CONFIG);
+  });
+
+  it('loads profile when complete with load action', async () => {
+    const manager = new FakeProfileManager({
+      synthetic: {
+        version: 1,
+        provider: 'openai',
+        model: 'hf:zai-org/GLM-4.6',
+        modelParams: { temperature: 0.7 },
+        ephemeralSettings: {
+          'base-url': 'https://api.synthetic.new/openai/v1',
+          'auth-keyfile': '/Users/example/.synthetic_key',
+        },
+      },
+    });
+
+    const result = await applyConfigCommand(
+      '/profile load synthetic',
+      BASE_CONFIG,
+      { profileManager: manager },
+    );
+    expect(result.messages[0]).toContain('Loaded profile: synthetic');
+    expect(result.nextConfig.provider).toBe('openai');
+    expect(result.nextConfig.model).toBe('hf:zai-org/GLM-4.6');
+    expect(result.nextConfig.baseUrl).toBe(
+      'https://api.synthetic.new/openai/v1',
+    );
+    expect(result.nextConfig.keyFilePath).toBe('/Users/example/.synthetic_key');
+  });
+
+  it('reports error for incomplete profile', async () => {
+    const manager = new FakeProfileManager({
+      synthetic: {
+        version: 1,
+        provider: 'openai',
+      },
+    });
+
+    const result = await applyConfigCommand(
+      '/profile load synthetic',
+      BASE_CONFIG,
+      { profileManager: manager },
+    );
+    expect(result.messages[0]).toContain('incomplete');
+    expect(result.nextConfig).toStrictEqual(BASE_CONFIG);
+  });
+
+  it('validates missing pieces', () => {
+    const messages = validateSessionConfig({ provider: 'openai' });
+    expect(messages.some((m) => m.toLowerCase().includes('base url'))).toBe(
+      true,
+    );
+    expect(messages.some((m) => m.toLowerCase().includes('model'))).toBe(true);
+    expect(messages.some((m) => m.toLowerCase().includes('key'))).toBe(true);
+  });
+
+  it('can skip model requirement', () => {
+    const messages = validateSessionConfig(
+      { provider: 'openai' },
+      { requireModel: false },
+    );
+    expect(messages.some((m) => m.toLowerCase().includes('model'))).toBe(false);
+    expect(messages.some((m) => m.toLowerCase().includes('base url'))).toBe(
+      true,
+    );
+  });
+});
+
+class FakeProfileManager {
+  private readonly profiles: Record<string, unknown>;
+
+  constructor(profiles: Record<string, unknown>) {
+    this.profiles = profiles;
+  }
+
+  loadProfile(name: string): Promise<Profile> {
+    const profile = this.profiles[name];
+    if (profile === undefined) {
+      return Promise.reject(new Error(`Profile '${name}' not found`));
+    }
+    return Promise.resolve(profile as Profile);
+  }
+
+  listProfiles(): Promise<string[]> {
+    return Promise.resolve(Object.keys(this.profiles));
+  }
+}
+
+describe('profileToConfigOptions', () => {
+  it('should convert ProfileData to ConfigSessionOptions', () => {
+    const profile: ProfileData = {
+      provider: 'openai',
+      model: 'gpt-4',
+      baseUrl: 'https://api.example.com',
+      authKeyfile: '/path/to/key',
+      ephemeralSettings: { streaming: 'disabled' },
+    };
+
+    const options = profileToConfigOptions(profile, '/work/dir');
+
+    expect(options.model).toBe('gpt-4');
+    expect(options.provider).toBe('openai');
+    expect(options.baseUrl).toBe('https://api.example.com');
+    expect(options.authKeyfile).toBe('/path/to/key');
+    expect(options.workingDir).toBe('/work/dir');
+  });
+
+  it('should handle ephemeral settings override for baseUrl', () => {
+    const profile: ProfileData = {
+      provider: 'openai',
+      model: 'gpt-4',
+      baseUrl: 'https://default.api.com',
+      ephemeralSettings: { 'base-url': 'https://override.api.com' },
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.baseUrl).toBe('https://override.api.com');
+  });
+
+  it('should handle ephemeral settings override for model', () => {
+    const profile: ProfileData = {
+      provider: 'gemini',
+      model: 'gemini-2.5-flash',
+      ephemeralSettings: { model: 'gemini-2.5-pro' },
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.model).toBe('gemini-2.5-pro');
+  });
+
+  it('should handle ephemeral settings override for authKeyfile', () => {
+    const profile: ProfileData = {
+      provider: 'gemini',
+      model: 'gemini-2.5-flash',
+      authKeyfile: '/default/key',
+      ephemeralSettings: { 'auth-keyfile': '/override/key' },
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.authKeyfile).toBe('/override/key');
+  });
+
+  it('should handle missing optional fields', () => {
+    const profile: ProfileData = {
+      provider: 'gemini',
+      model: 'gemini-2.5-flash',
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.model).toBe('gemini-2.5-flash');
+    expect(options.provider).toBe('gemini');
+    expect(options.baseUrl).toBeUndefined();
+    expect(options.authKeyfile).toBeUndefined();
+  });
+
+  it('should handle apiKey from ephemeral settings', () => {
+    const profile: ProfileData = {
+      provider: 'openai',
+      model: 'gpt-4',
+      ephemeralSettings: { 'auth-key': 'sk-test-key-12345' },
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.apiKey).toBe('sk-test-key-12345');
+  });
+
+  it('should use authKeyfile from profile when not in ephemeral settings', () => {
+    const profile: ProfileData = {
+      provider: 'gemini',
+      model: 'gemini-2.5-flash',
+      authKeyfile: '/profile/key',
+    };
+
+    const options = profileToConfigOptions(profile, '/work');
+
+    expect(options.authKeyfile).toBe('/profile/key');
+  });
+});