byterover-cli 2.2.0 → 2.3.0

package/dist/server/infra/transport/handlers/model-handler.js

@@ -1,15 +1,17 @@
 import { ModelEvents, } from '../../../../shared/transport/events/model-events.js';
 import { TransportDaemonEventNames } from '../../../core/domain/transport/schemas.js';
-import { getModelFetcher } from '../../http/provider-model-fetcher-registry.js';
+import { getModelFetcher as getModelFetcherDefault } from '../../http/provider-model-fetcher-registry.js';
 /**
  * Handles model:* events.
  * Business logic for model listing and selection — no terminal/UI calls.
  */
 export class ModelHandler {
+    getModelFetcher;
     providerConfigStore;
     providerKeychainStore;
     transport;
     constructor(deps) {
+        this.getModelFetcher = deps.getModelFetcher ?? getModelFetcherDefault;
         this.providerConfigStore = deps.providerConfigStore;
         this.providerKeychainStore = deps.providerKeychainStore;
         this.transport = deps.transport;
@@ -22,18 +24,21 @@ export class ModelHandler {
     setupList() {
         this.transport.onRequest(ModelEvents.LIST, async (data) => {
             const { providerId } = data;
-            const fetcher = await getModelFetcher(providerId);
+            const fetcher = await this.getModelFetcher(providerId);
             if (!fetcher) {
                 return { favorites: [], models: [], recent: [] };
             }
             // Fetch models from provider API using the correct per-provider fetcher
             let fetchedModels;
             try {
+                const config = await this.providerConfigStore.read();
+                const authMethod = config.providers[providerId]?.authMethod;
                 const apiKey = await this.providerKeychainStore.getApiKey(providerId);
-                fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+                fetchedModels = await fetcher.fetchModels(apiKey ?? '', { authMethod });
             }
-            catch {
-                return { favorites: [], models: [], recent: [] };
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Failed to load models';
+                return { error: message, favorites: [], models: [], recent: [] };
             }
             const models = fetchedModels.map((m) => ({
                 contextLength: m.contextLength,
@@ -61,12 +66,14 @@ export class ModelHandler {
     setupListByProviders() {
         this.transport.onRequest(ModelEvents.LIST_BY_PROVIDERS, async (data) => {
             const { providerIds } = data;
+            const config = await this.providerConfigStore.read();
             const results = await Promise.allSettled(providerIds.map(async (providerId) => {
-                const fetcher = await getModelFetcher(providerId);
+                const fetcher = await this.getModelFetcher(providerId);
                 if (!fetcher)
                     return [];
+                const authMethod = config.providers[providerId]?.authMethod;
                 const apiKey = await this.providerKeychainStore.getApiKey(providerId);
-                const fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+                const fetchedModels = await fetcher.fetchModels(apiKey ?? '', { authMethod });
                 return fetchedModels.map((model) => ({
                     contextLength: model.contextLength,
                     description: model.description,
@@ -98,10 +105,45 @@ export class ModelHandler {
     }
     setupSetActive() {
         this.transport.onRequest(ModelEvents.SET_ACTIVE, async (data) => {
-            await this.providerConfigStore.setActiveProvider(data.providerId);
-            await this.providerConfigStore.setActiveModel(data.providerId, data.modelId, data.contextLength);
-            this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
-            return { success: true };
+            try {
+                const config = await this.providerConfigStore.read();
+                const providerConfig = config.providers[data.providerId];
+                if (!providerConfig) {
+                    return {
+                        error: `Provider "${data.providerId}" is not connected`,
+                        success: false,
+                    };
+                }
+                let matchedModel;
+                // Validate model against allowed list for OAuth providers
+                if (providerConfig.authMethod === 'oauth') {
+                    const fetcher = await this.getModelFetcher(data.providerId);
+                    if (!fetcher) {
+                        return {
+                            error: `Cannot validate model for OAuth-connected ${data.providerId}: model fetcher unavailable`,
+                            success: false,
+                        };
+                    }
+                    const allowedModels = await fetcher.fetchModels('', { authMethod: 'oauth' });
+                    matchedModel = allowedModels.find((m) => m.id === data.modelId);
+                    if (!matchedModel) {
+                        const allowedIds = allowedModels.map((m) => m.id).join(', ');
+                        return {
+                            error: `Model "${data.modelId}" is not available for OAuth-connected ${data.providerId}. Allowed models: ${allowedIds}`,
+                            success: false,
+                        };
+                    }
+                }
+                const contextLength = data.contextLength ?? matchedModel?.contextLength;
+                await this.providerConfigStore.setActiveProvider(data.providerId);
+                await this.providerConfigStore.setActiveModel(data.providerId, data.modelId, contextLength);
+                this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+                return { success: true };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Failed to set active model';
+                return { error: message, success: false };
+            }
         });
     }
 }

package/dist/server/infra/transport/handlers/provider-handler.d.ts

@@ -1,9 +1,24 @@
 import type { IProviderConfigStore } from '../../../core/interfaces/i-provider-config-store.js';
 import type { IProviderKeychainStore } from '../../../core/interfaces/i-provider-keychain-store.js';
+import type { IProviderOAuthTokenStore } from '../../../core/interfaces/i-provider-oauth-token-store.js';
+import type { IBrowserLauncher } from '../../../core/interfaces/services/i-browser-launcher.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import type { PkceParameters, ProviderTokenResponse, TokenExchangeParams } from '../../provider-oauth/index.js';
+import { ProviderCallbackServer } from '../../provider-oauth/index.js';
 export interface ProviderHandlerDeps {
+    browserLauncher: IBrowserLauncher;
+    /** Factory for creating callback servers (injectable for testing) */
+    createCallbackServer?: (options: {
+        callbackPath?: string;
+        port: number;
+    }) => ProviderCallbackServer;
+    /** Token exchange function (injectable for testing) */
+    exchangeCodeForTokens?: (params: TokenExchangeParams) => Promise<ProviderTokenResponse>;
+    /** PKCE generator function (injectable for testing) */
+    generatePkce?: () => PkceParameters;
     providerConfigStore: IProviderConfigStore;
     providerKeychainStore: IProviderKeychainStore;
+    providerOAuthTokenStore: IProviderOAuthTokenStore;
     transport: ITransportServer;
 }
 /**
@@ -11,15 +26,26 @@ export interface ProviderHandlerDeps {
  * Business logic for provider management — no terminal/UI calls.
  */
 export declare class ProviderHandler {
+    private readonly browserLauncher;
+    private readonly createCallbackServer;
+    private readonly exchangeCodeForTokens;
+    private readonly generatePkce;
+    private readonly oauthFlows;
     private readonly providerConfigStore;
     private readonly providerKeychainStore;
+    private readonly providerOAuthTokenStore;
     private readonly transport;
     constructor(deps: ProviderHandlerDeps);
     setup(): void;
+    private cleanupFlowsForClient;
+    private setupAwaitOAuthCallback;
+    private setupCancelOAuth;
     private setupConnect;
     private setupDisconnect;
     private setupGetActive;
     private setupList;
     private setupSetActive;
+    private setupStartOAuth;
+    private setupSubmitOAuthCode;
     private setupValidateApiKey;
 }

package/dist/server/infra/transport/handlers/provider-handler.js

@@ -4,17 +4,29 @@ import { TransportDaemonEventNames } from '../../../core/domain/transport/schema
 import { getErrorMessage } from '../../../utils/error-helpers.js';
 import { processLog } from '../../../utils/process-logger.js';
 import { validateApiKey as validateApiKeyViaFetcher } from '../../http/provider-model-fetcher-registry.js';
+import { computeExpiresAt, exchangeCodeForTokens as defaultExchangeCodeForTokens, generatePkce as defaultGeneratePkce, parseAccountIdFromIdToken, ProviderCallbackServer, ProviderCallbackTimeoutError, } from '../../provider-oauth/index.js';
 /**
  * Handles provider:* events.
  * Business logic for provider management — no terminal/UI calls.
  */
 export class ProviderHandler {
+    browserLauncher;
+    createCallbackServer;
+    exchangeCodeForTokens;
+    generatePkce;
+    oauthFlows = new Map();
     providerConfigStore;
     providerKeychainStore;
+    providerOAuthTokenStore;
     transport;
     constructor(deps) {
+        this.browserLauncher = deps.browserLauncher;
+        this.createCallbackServer = deps.createCallbackServer ?? ((options) => new ProviderCallbackServer(options));
+        this.exchangeCodeForTokens = deps.exchangeCodeForTokens ?? defaultExchangeCodeForTokens;
+        this.generatePkce = deps.generatePkce ?? defaultGeneratePkce;
         this.providerConfigStore = deps.providerConfigStore;
         this.providerKeychainStore = deps.providerKeychainStore;
+        this.providerOAuthTokenStore = deps.providerOAuthTokenStore;
         this.transport = deps.transport;
     }
     setup() {
@@ -24,6 +36,99 @@ export class ProviderHandler {
         this.setupList();
         this.setupSetActive();
         this.setupValidateApiKey();
+        this.setupStartOAuth();
+        this.setupAwaitOAuthCallback();
+        this.setupCancelOAuth();
+        this.setupSubmitOAuthCode();
+        // Clean up OAuth flows when a client disconnects (prevents callback server port leaks)
+        this.transport.onDisconnection((clientId) => {
+            this.cleanupFlowsForClient(clientId);
+        });
+    }
+    cleanupFlowsForClient(clientId) {
+        for (const [providerId, flow] of this.oauthFlows.entries()) {
+            if (flow.clientId === clientId) {
+                flow.callbackServer?.stop().catch(() => { });
+                this.oauthFlows.delete(providerId);
+            }
+        }
+    }
+    setupAwaitOAuthCallback() {
+        this.transport.onRequest(ProviderEvents.AWAIT_OAUTH_CALLBACK, async (data) => {
+            const flow = this.oauthFlows.get(data.providerId);
+            if (!flow?.callbackServer) {
+                return { error: 'No active OAuth flow for this provider', success: false };
+            }
+            if (flow.awaitInProgress) {
+                return { error: 'OAuth callback is already being awaited for this provider', success: false };
+            }
+            flow.awaitInProgress = true;
+            try {
+                // Block until callback or timeout (5 min default in ProviderCallbackServer)
+                const callbackResult = await flow.callbackServer.waitForCallback(flow.state);
+                // Exchange code for tokens
+                const providerDef = getProviderById(data.providerId);
+                if (!providerDef?.oauth) {
+                    return { error: 'Provider does not support OAuth', success: false };
+                }
+                const oauthConfig = providerDef.oauth;
+                const contentType = oauthConfig.tokenContentType === 'form' ? 'application/x-www-form-urlencoded' : 'application/json';
+                const tokens = await this.exchangeCodeForTokens({
+                    clientId: oauthConfig.clientId,
+                    code: callbackResult.code,
+                    codeVerifier: flow.codeVerifier,
+                    contentType,
+                    redirectUri: oauthConfig.redirectUri,
+                    tokenUrl: oauthConfig.tokenUrl,
+                });
+                // Parse JWT id_token for account ID
+                const oauthAccountId = tokens.id_token ? parseAccountIdFromIdToken(tokens.id_token) : undefined;
+                // Store access token as the "API key" in keychain
+                await this.providerKeychainStore.setApiKey(data.providerId, tokens.access_token);
+                // Store refresh token + expiry in encrypted OAuth token store
+                if (tokens.refresh_token) {
+                    const expiresAt = tokens.expires_in ? computeExpiresAt(tokens.expires_in) : computeExpiresAt(3600); // 1-hour default when provider omits expires_in
+                    await this.providerOAuthTokenStore.set(data.providerId, {
+                        expiresAt,
+                        refreshToken: tokens.refresh_token,
+                    });
+                }
+                // Connect provider — secrets stored in keychain + encrypted token store, not config
+                // OAuth providers may define their own default model (e.g., Codex for OpenAI OAuth)
+                const defaultModel = oauthConfig.defaultModel ?? providerDef.defaultModel;
+                await this.providerConfigStore.connectProvider(data.providerId, {
+                    activeModel: defaultModel,
+                    authMethod: 'oauth',
+                    oauthAccountId,
+                });
+                // Broadcast update
+                this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+                return { success: true };
+            }
+            catch (error) {
+                if (error instanceof ProviderCallbackTimeoutError) {
+                    return { error: 'Authentication timed out. Please try again.', success: false };
+                }
+                return { error: getErrorMessage(error), success: false };
+            }
+            finally {
+                // Only clean up if this is still the same flow (guard against concurrent START_OAUTH)
+                if (this.oauthFlows.get(data.providerId) === flow) {
+                    await flow.callbackServer?.stop().catch(() => { });
+                    this.oauthFlows.delete(data.providerId);
+                }
+            }
+        });
+    }
+    setupCancelOAuth() {
+        this.transport.onRequest(ProviderEvents.CANCEL_OAUTH, async (data) => {
+            const flow = this.oauthFlows.get(data.providerId);
+            if (flow?.callbackServer) {
+                await flow.callbackServer.stop().catch(() => { });
+            }
+            this.oauthFlows.delete(data.providerId);
+            return { success: true };
+        });
     }
     setupConnect() {
         this.transport.onRequest(ProviderEvents.CONNECT, async (data) => {
@@ -35,6 +140,7 @@ export class ProviderHandler {
             const provider = getProviderById(providerId);
             await this.providerConfigStore.connectProvider(providerId, {
                 activeModel: provider?.defaultModel,
+                authMethod: apiKey ? 'api-key' : undefined,
                 baseUrl,
             });
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
@@ -46,6 +152,7 @@ export class ProviderHandler {
             const { providerId } = data;
             await this.providerConfigStore.disconnectProvider(providerId);
             await this.providerKeychainStore.deleteApiKey(providerId);
+            await this.providerOAuthTokenStore.delete(providerId);
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
             return { success: true };
         });
@@ -64,19 +171,28 @@ export class ProviderHandler {
                 processLog(`[ProviderHandler] getActiveProvider failed: ${error instanceof Error ? error.message : String(error)}`);
                 return '';
             });
-            const providers = await Promise.all(definitions.map(async (def) => ({
-                apiKeyUrl: def.apiKeyUrl,
-                category: def.category,
-                description: def.description,
-                id: def.id,
-                isConnected: await this.providerConfigStore.isProviderConnected(def.id).catch((error) => {
-                    processLog(`[ProviderHandler] isProviderConnected failed for ${def.id}: ${error instanceof Error ? error.message : String(error)}`);
-                    return false;
-                }),
-                isCurrent: def.id === activeProviderId,
-                name: def.name,
-                requiresApiKey: providerRequiresApiKey(def.id),
-            })));
+            const config = await this.providerConfigStore.read().catch(() => null);
+            const providers = await Promise.all(definitions.map(async (def) => {
+                const providerConfig = config?.providers[def.id];
+                const authMethod = providerConfig?.authMethod;
+                return {
+                    apiKeyUrl: def.apiKeyUrl,
+                    authMethod,
+                    category: def.category,
+                    description: def.description,
+                    id: def.id,
+                    isConnected: await this.providerConfigStore.isProviderConnected(def.id).catch((error) => {
+                        processLog(`[ProviderHandler] isProviderConnected failed for ${def.id}: ${error instanceof Error ? error.message : String(error)}`);
+                        return false;
+                    }),
+                    isCurrent: def.id === activeProviderId,
+                    name: def.name,
+                    oauthCallbackMode: def.oauth?.callbackMode,
+                    oauthLabel: def.oauth?.modes[0]?.label,
+                    requiresApiKey: providerRequiresApiKey(def.id, authMethod),
+                    supportsOAuth: Boolean(def.oauth),
+                };
+            }));
             return { providers };
         });
     }
@@ -87,6 +203,92 @@ export class ProviderHandler {
             return { success: true };
         });
     }
+    /* eslint-disable camelcase -- OAuth query params follow RFC 6749 naming */
+    setupStartOAuth() {
+        this.transport.onRequest(ProviderEvents.START_OAUTH, async (data, clientId) => {
+            const providerDef = getProviderById(data.providerId);
+            if (!providerDef?.oauth) {
+                const errorResponse = {
+                    authUrl: '',
+                    callbackMode: 'auto',
+                    error: 'Provider does not support OAuth',
+                    success: false,
+                };
+                return errorResponse;
+            }
+            try {
+                const oauthConfig = providerDef.oauth;
+                // Clean up any existing flow for this provider (race condition guard)
+                const existingFlow = this.oauthFlows.get(data.providerId);
+                if (existingFlow?.callbackServer) {
+                    await existingFlow.callbackServer.stop().catch(() => { });
+                }
+                this.oauthFlows.delete(data.providerId);
+                // Generate PKCE parameters
+                const pkce = this.generatePkce();
+                // Build auth URL
+                const mode = oauthConfig.modes.find((m) => m.id === (data.mode ?? 'default')) ?? oauthConfig.modes[0];
+                const params = new URLSearchParams({
+                    client_id: oauthConfig.clientId,
+                    code_challenge: pkce.codeChallenge,
+                    code_challenge_method: 'S256',
+                    redirect_uri: oauthConfig.redirectUri,
+                    response_type: 'code',
+                    scope: oauthConfig.scopes,
+                    state: pkce.state,
+                });
+                // Provider-specific extra params (e.g. OpenAI's codex_cli_simplified_flow)
+                if (oauthConfig.extraParams) {
+                    for (const [key, value] of Object.entries(oauthConfig.extraParams)) {
+                        params.set(key, value);
+                    }
+                }
+                const authUrl = `${mode.authUrl}?${params.toString()}`;
+                // Start callback server for auto mode
+                let callbackServer;
+                if (oauthConfig.callbackMode === 'auto' && oauthConfig.callbackPort) {
+                    callbackServer = this.createCallbackServer({ port: oauthConfig.callbackPort });
+                    await callbackServer.start();
+                }
+                // Store flow state
+                this.oauthFlows.set(data.providerId, {
+                    callbackServer,
+                    clientId,
+                    codeVerifier: pkce.codeVerifier,
+                    state: pkce.state,
+                });
+                // Open browser (non-fatal on failure)
+                try {
+                    await this.browserLauncher.open(authUrl);
+                }
+                catch {
+                    processLog(`[ProviderHandler] Browser launch failed for OAuth — user can copy the URL`);
+                }
+                return { authUrl, callbackMode: oauthConfig.callbackMode, success: true };
+            }
+            catch (error) {
+                // Clean up callback server if it was started but flow setup failed
+                const partialFlow = this.oauthFlows.get(data.providerId);
+                if (partialFlow?.callbackServer) {
+                    await partialFlow.callbackServer.stop().catch(() => { });
+                }
+                this.oauthFlows.delete(data.providerId);
+                const errorResponse = {
+                    authUrl: '',
+                    callbackMode: 'auto',
+                    error: getErrorMessage(error),
+                    success: false,
+                };
+                return errorResponse;
+            }
+        });
+    }
+    /* eslint-enable camelcase */
+    setupSubmitOAuthCode() {
+        this.transport.onRequest(ProviderEvents.SUBMIT_OAUTH_CODE, 
+        // Stub for M2 (Anthropic code-paste flow)
+        async () => ({ error: 'Code submission is not yet supported for this provider', success: false }));
+    }
     setupValidateApiKey() {
         this.transport.onRequest(ProviderEvents.VALIDATE_API_KEY, async (data) => {
             try {

package/dist/shared/constants/oauth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ChatGPT OAuth (Codex) API base URL — single source of truth.
+ * Used by the agent's OpenAI provider module and the server's provider config resolver.
+ */
+export declare const CHATGPT_OAUTH_BASE_URL = "https://chatgpt.com/backend-api/codex";
+/**
+ * Originator header/param value sent to OpenAI in OAuth flows.
+ */
+export declare const CHATGPT_OAUTH_ORIGINATOR = "byterover";
+/**
+ * OAuth callback timeout in milliseconds (5 minutes).
+ * Used by the callback server, TUI await-oauth-callback mutation, and CLI connect command.
+ */
+export declare const OAUTH_CALLBACK_TIMEOUT_MS = 300000;

package/dist/shared/constants/oauth.js

@@ -0,0 +1,14 @@
+/**
+ * ChatGPT OAuth (Codex) API base URL — single source of truth.
+ * Used by the agent's OpenAI provider module and the server's provider config resolver.
+ */
+export const CHATGPT_OAUTH_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+/**
+ * Originator header/param value sent to OpenAI in OAuth flows.
+ */
+export const CHATGPT_OAUTH_ORIGINATOR = 'byterover';
+/**
+ * OAuth callback timeout in milliseconds (5 minutes).
+ * Used by the callback server, TUI await-oauth-callback mutation, and CLI connect command.
+ */
+export const OAUTH_CALLBACK_TIMEOUT_MS = 300_000;

package/dist/shared/transport/events/index.d.ts

@@ -86,11 +86,16 @@ export declare const AllEventGroups: readonly [{
     readonly COMPLETE: "onboarding:complete";
     readonly GET_STATE: "onboarding:getState";
 }, {
+    readonly AWAIT_OAUTH_CALLBACK: "provider:awaitOAuthCallback";
+    readonly CANCEL_OAUTH: "provider:cancelOAuth";
     readonly CONNECT: "provider:connect";
     readonly DISCONNECT: "provider:disconnect";
     readonly GET_ACTIVE: "provider:getActive";
     readonly LIST: "provider:list";
     readonly SET_ACTIVE: "provider:setActive";
+    readonly START_OAUTH: "provider:startOAuth";
+    readonly SUBMIT_OAUTH_CODE: "provider:submitOAuthCode";
+    readonly UPDATED: "provider:updated";
     readonly VALIDATE_API_KEY: "provider:validateApiKey";
 }, {
     readonly EXECUTE: "pull:execute";

package/dist/shared/transport/events/model-events.d.ts

@@ -9,6 +9,7 @@ export interface ModelListRequest {
 }
 export interface ModelListResponse {
     activeModel?: string;
+    error?: string;
     favorites: string[];
     models: ModelDTO[];
     recent: string[];
@@ -26,5 +27,6 @@ export interface ModelSetActiveRequest {
     providerId: string;
 }
 export interface ModelSetActiveResponse {
+    error?: string;
     success: boolean;
 }

package/dist/shared/transport/events/provider-events.d.ts

@@ -1,10 +1,15 @@
 import type { ProviderDTO } from '../types/dto.js';
 export declare const ProviderEvents: {
+    readonly AWAIT_OAUTH_CALLBACK: "provider:awaitOAuthCallback";
+    readonly CANCEL_OAUTH: "provider:cancelOAuth";
     readonly CONNECT: "provider:connect";
     readonly DISCONNECT: "provider:disconnect";
     readonly GET_ACTIVE: "provider:getActive";
     readonly LIST: "provider:list";
     readonly SET_ACTIVE: "provider:setActive";
+    readonly START_OAUTH: "provider:startOAuth";
+    readonly SUBMIT_OAUTH_CODE: "provider:submitOAuthCode";
+    readonly UPDATED: "provider:updated";
     readonly VALIDATE_API_KEY: "provider:validateApiKey";
 };
 export interface ProviderListResponse {
@@ -42,3 +47,34 @@ export interface ProviderSetActiveRequest {
 export interface ProviderSetActiveResponse {
     success: boolean;
 }
+export interface ProviderCancelOAuthRequest {
+    providerId: string;
+}
+export interface ProviderCancelOAuthResponse {
+    success: boolean;
+}
+export interface ProviderStartOAuthRequest {
+    mode?: string;
+    providerId: string;
+}
+export interface ProviderStartOAuthResponse {
+    authUrl: string;
+    callbackMode: 'auto' | 'code-paste';
+    error?: string;
+    success: boolean;
+}
+export interface ProviderAwaitOAuthCallbackRequest {
+    providerId: string;
+}
+export interface ProviderAwaitOAuthCallbackResponse {
+    error?: string;
+    success: boolean;
+}
+export interface ProviderSubmitOAuthCodeRequest {
+    code: string;
+    providerId: string;
+}
+export interface ProviderSubmitOAuthCodeResponse {
+    error?: string;
+    success: boolean;
+}

package/dist/shared/transport/events/provider-events.js

@@ -1,8 +1,13 @@
 export const ProviderEvents = {
+    AWAIT_OAUTH_CALLBACK: 'provider:awaitOAuthCallback',
+    CANCEL_OAUTH: 'provider:cancelOAuth',
     CONNECT: 'provider:connect',
     DISCONNECT: 'provider:disconnect',
     GET_ACTIVE: 'provider:getActive',
     LIST: 'provider:list',
     SET_ACTIVE: 'provider:setActive',
+    START_OAUTH: 'provider:startOAuth',
+    SUBMIT_OAUTH_CODE: 'provider:submitOAuthCode',
+    UPDATED: 'provider:updated',
     VALIDATE_API_KEY: 'provider:validateApiKey',
 };

package/dist/shared/transport/types/dto.d.ts

@@ -49,13 +49,17 @@ export interface ConnectorDTO {
 }
 export interface ProviderDTO {
     apiKeyUrl?: string;
+    authMethod?: 'api-key' | 'oauth';
     category: 'other' | 'popular';
     description: string;
     id: string;
     isConnected: boolean;
     isCurrent: boolean;
     name: string;
+    oauthCallbackMode?: 'auto' | 'code-paste';
+    oauthLabel?: string;
     requiresApiKey: boolean;
+    supportsOAuth: boolean;
 }
 export interface ModelDTO {
     contextLength: number;

package/dist/tui/features/model/api/set-active-model.d.ts

@@ -5,7 +5,7 @@ export type SetActiveModelDTO = {
     modelId: string;
     providerId: string;
 };
-export declare const setActiveModel: ({ contextLength, modelId, providerId }: SetActiveModelDTO) => Promise<ModelSetActiveResponse>;
+export declare const setActiveModel: ({ contextLength, modelId, providerId, }: SetActiveModelDTO) => Promise<ModelSetActiveResponse>;
 type UseSetActiveModelOptions = {
     mutationConfig?: MutationConfig<typeof setActiveModel>;
 };

package/dist/tui/features/model/api/set-active-model.js

@@ -1,11 +1,19 @@
 import { useMutation } from '@tanstack/react-query';
-import { ModelEvents } from '../../../../shared/transport/events/index.js';
+import { ModelEvents, } from '../../../../shared/transport/events/index.js';
 import { useTransportStore } from '../../../stores/transport-store.js';
-export const setActiveModel = ({ contextLength, modelId, providerId }) => {
+export const setActiveModel = async ({ contextLength, modelId, providerId, }) => {
     const { apiClient } = useTransportStore.getState();
     if (!apiClient)
-        return Promise.reject(new Error('Not connected'));
-    return apiClient.request(ModelEvents.SET_ACTIVE, { contextLength, modelId, providerId });
+        throw new Error('Not connected');
+    const response = await apiClient.request(ModelEvents.SET_ACTIVE, {
+        contextLength,
+        modelId,
+        providerId,
+    });
+    if (!response.success && response.error) {
+        throw new Error(response.error);
+    }
+    return response;
 };
 export const useSetActiveModel = ({ mutationConfig } = {}) => useMutation({
     ...mutationConfig,

package/dist/tui/features/provider/api/await-oauth-callback.d.ts

@@ -0,0 +1,11 @@
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type ProviderAwaitOAuthCallbackResponse } from '../../../../shared/transport/events/index.js';
+export type AwaitOAuthCallbackDTO = {
+    providerId: string;
+};
+export declare const awaitOAuthCallback: ({ providerId, }: AwaitOAuthCallbackDTO) => Promise<ProviderAwaitOAuthCallbackResponse>;
+type UseAwaitOAuthCallbackOptions = {
+    mutationConfig?: MutationConfig<typeof awaitOAuthCallback>;
+};
+export declare const useAwaitOAuthCallback: ({ mutationConfig }?: UseAwaitOAuthCallbackOptions) => import("@tanstack/react-query").UseMutationResult<ProviderAwaitOAuthCallbackResponse, Error, AwaitOAuthCallbackDTO, unknown>;
+export {};