@equinor/fusion-framework-cli-plugin-ai-base 2.0.1 → 3.0.0

package/src/options/types.ts

@@ -1,42 +1,22 @@
 /**
- * Hand-authored TypeScript interface for AI CLI command options.
+ * Base options for all Fusion AI CLI commands.
  *
- * @remarks
- * Use {@link AiOptions} when you need a lightweight type without pulling in Zod.
- * For runtime validation prefer {@link AiOptionsSchema} from the schema module.
- *
- * @packageDocumentation
- */
-
-/**
- * Configuration options for AI-related CLI commands.
- *
- * This interface defines all available options for configuring Azure OpenAI services
- * and Azure Cognitive Search integration. Required fields must be provided either
- * via command-line arguments or environment variables. Optional fields enable
- * specific features (chat, embeddings, vector search) when provided.
- *
- * @remarks
- * - All required fields (apiKey, apiVersion, instance) must be provided for any AI operation
- * - Chat operations require `openaiChatDeployment`
- * - Embedding operations require `openaiEmbeddingDeployment`
- * - Vector search requires all three Azure Search fields plus `openaiEmbeddingDeployment`
+ * The service URL and token are resolved automatically from Fusion
+ * service discovery using the provided environment and authentication options.
  */
 export interface AiOptions {
-  /** Azure OpenAI API key for authentication with Azure OpenAI services */
-  openaiApiKey: string;
-  /** Azure OpenAI API version (e.g., '2024-02-15-preview') */
-  openaiApiVersion: string;
-  /** Azure OpenAI instance name (the resource name in Azure) */
-  openaiInstance: string;
-  /** Azure OpenAI chat model deployment name. Required for chat operations */
-  openaiChatDeployment?: string;
-  /** Azure OpenAI embedding model deployment name. Required for embedding and vector search operations */
-  openaiEmbeddingDeployment?: string;
-  /** Azure Cognitive Search endpoint URL. Required for vector search operations */
-  azureSearchEndpoint?: string;
-  /** Azure Cognitive Search API key. Required for vector search operations */
-  azureSearchApiKey?: string;
-  /** Azure Cognitive Search index name. Required for vector search operations */
-  azureSearchIndexName?: string;
+  /** Fusion environment used for service discovery (e.g. `ci`, `fprd`). */
+  env?: string;
+  /** Bearer token passed directly to the auth module (overrides clientId/tenantId). */
+  token?: string;
+  /** Azure AD tenant ID for MSAL silent authentication. */
+  tenantId?: string;
+  /** Azure AD client ID for MSAL silent authentication. */
+  clientId?: string;
+  /** Azure OpenAI chat model deployment name. Required for chat operations. */
+  chatModel?: string;
+  /** Azure OpenAI embedding model deployment name. Required for embedding and index operations. */
+  embedModel?: string;
+  /** Azure AI Search index name. Required for vector search / indexing operations. */
+  indexName?: string;
 }

package/src/options/with-options.ts

@@ -1,159 +1,65 @@
 import { type Command, InvalidOptionArgumentError } from 'commander';
 import {
-  apiInstanceOption,
-  apiKeyOption,
-  apiVersionOption,
-  azureSearchApiKeyOption,
-  azureSearchEndpointOption,
-  azureSearchIndexNameOption,
-  chatDeploymentOption,
-  embeddingDeploymentOption,
+  chatModelOption,
+  clientIdOption,
+  embedModelOption,
+  envOption,
+  indexNameOption,
+  tenantIdOption,
+  tokenOption,
 } from './options.js';
 
 /**
- * Enhances a Commander command with AI-related options and validation.
+ * Enhances a Commander command with Fusion AI options and validation.
  *
- * This function adds Azure OpenAI and Azure Cognitive Search options to the provided
- * command, along with pre-action validation hooks to ensure required options are provided.
- * The function allows selective inclusion of chat, embedding, and search capabilities
- * based on the command's requirements.
+ * Core auth options (`--env`, `--token`, `--tenant-id`, `--client-id`) are always
+ * added.  When no explicit `--token` is provided, the framework will authenticate
+ * via MSAL and resolve the AI service endpoint from Fusion service discovery.
  *
- * Options added:
- * - Core: `openaiApiKey`, `openaiApiVersion`, `openaiInstance` (always included)
- * - Chat: `openaiChatDeployment` (if includeChat is true)
- * - Embedding: `openaiEmbeddingDeployment` (if includeEmbedding is true)
- * - Search: `azureSearchEndpoint`, `azureSearchApiKey`, `azureSearchIndexName` (if includeSearch is true)
+ * Pass flags to include optional chat, embed, or index options and make
+ * them required at runtime via the `preAction` validation hook.
  *
- * @param command - The Commander command instance to enhance with AI options
- * @param args - Optional configuration object for selective feature inclusion
- * @param args.includeEmbedding - Whether to include and require embedding deployment option (default: false)
- * @param args.includeChat - Whether to include and require chat deployment option (default: false)
- * @param args.includeSearch - Whether to include and require Azure Search options (default: false)
- * @returns The enhanced command with AI options and validation hooks attached
- * @throws {InvalidOptionArgumentError} During command execution if required options are missing or invalid
- *
- * @example
- * ```ts
- * const chatCommand = createCommand('chat')
- *   .description('Start a chat session');
- *
- * withOptions(chatCommand, { includeChat: true });
- * ```
+ * @param command - The Commander command to decorate with options.
+ * @param args - Feature flags controlling which optional options to add.
+ * @param args.includeChat - Add `--chat-model` and validate it at runtime.
+ * @param args.includeEmbedding - Add `--embed-model` and validate it at runtime.
+ * @param args.includeSearch - Add `--index-name` and validate it at runtime.
+ * @returns The decorated command.
  */
 export const withOptions = (
   command: Command,
   args?: Partial<{
-    includeEmbedding: boolean;
     includeChat: boolean;
+    includeEmbedding: boolean;
     includeSearch: boolean;
   }>,
 ): Command => {
-  // Core authentication options
-  command.addOption(apiKeyOption);
-  command.addOption(apiVersionOption);
-  command.addOption(apiInstanceOption);
-
-  // Deployment options
-  if (args?.includeChat === true) {
-    command.addOption(chatDeploymentOption);
-  }
+  command.addOption(envOption);
+  command.addOption(tokenOption);
+  command.addOption(tenantIdOption);
+  command.addOption(clientIdOption);
 
-  if (args?.includeEmbedding === true) {
-    command.addOption(embeddingDeploymentOption);
-  }
+  if (args?.includeChat) command.addOption(chatModelOption);
+  if (args?.includeEmbedding) command.addOption(embedModelOption);
+  if (args?.includeSearch) command.addOption(indexNameOption);
 
-  // Azure Search options
-  if (args?.includeSearch === true) {
-    command.addOption(azureSearchEndpointOption);
-    command.addOption(azureSearchApiKeyOption);
-    command.addOption(azureSearchIndexNameOption);
-  }
-
-  // Validation hook
   command.hook('preAction', (thisCommand) => {
-    const options = thisCommand.opts();
+    const opts = thisCommand.opts();
 
-    // Validate API key
-    if (
-      !options.openaiApiKey ||
-      typeof options.openaiApiKey !== 'string' ||
-      options.openaiApiKey.trim() === ''
-    ) {
+    if (args?.includeChat && !opts.chatModel?.trim()) {
       throw new InvalidOptionArgumentError(
-        'Azure OpenAI API key is required. Provide it via --openai-api-key option or AZURE_OPENAI_API_KEY environment variable.',
+        'Chat model name is required. Provide --chat-model or set FUSION_AI_CHAT_MODEL.',
       );
     }
-
-    // Validate API version
-    if (!options.openaiApiVersion || typeof options.openaiApiVersion !== 'string') {
-      throw new InvalidOptionArgumentError('API version must be a non-empty string.');
-    }
-
-    // Validate instance name
-    if (
-      !options.openaiInstance ||
-      typeof options.openaiInstance !== 'string' ||
-      options.openaiInstance.trim() === ''
-    ) {
+    if (args?.includeEmbedding && !opts.embedModel?.trim()) {
       throw new InvalidOptionArgumentError(
-        'Azure OpenAI instance name is required. Provide it via --openai-instance option or AZURE_OPENAI_INSTANCE_NAME environment variable.',
+        'Embedding model name is required. Provide --embed-model or set FUSION_AI_EMBED_MODEL.',
       );
     }
-
-    if (args?.includeChat === true) {
-      if (
-        !options.openaiChatDeployment ||
-        typeof options.openaiChatDeployment !== 'string' ||
-        options.openaiChatDeployment.trim() === ''
-      ) {
-        throw new InvalidOptionArgumentError(
-          'Chat deployment name is required and must be a non-empty string.',
-        );
-      }
-    }
-
-    if (args?.includeEmbedding === true) {
-      if (
-        !options.openaiEmbeddingDeployment ||
-        typeof options.openaiEmbeddingDeployment !== 'string' ||
-        options.openaiEmbeddingDeployment.trim() === ''
-      ) {
-        throw new InvalidOptionArgumentError(
-          'Azure OpenAI embedding deployment name is required. Provide it via --openai-embedding-deployment option or AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME environment variable.',
-        );
-      }
-    }
-
-    if (args?.includeSearch === true) {
-      if (
-        !options.azureSearchEndpoint ||
-        typeof options.azureSearchEndpoint !== 'string' ||
-        options.azureSearchEndpoint.trim() === ''
-      ) {
-        throw new InvalidOptionArgumentError(
-          'Azure Search endpoint is required and must be a non-empty string.',
-        );
-      }
-
-      if (
-        !options.azureSearchApiKey ||
-        typeof options.azureSearchApiKey !== 'string' ||
-        options.azureSearchApiKey.trim() === ''
-      ) {
-        throw new InvalidOptionArgumentError(
-          'Azure Search API key is required. Provide it via --azure-search-api-key option or AZURE_SEARCH_API_KEY environment variable.',
-        );
-      }
-
-      if (
-        !options.azureSearchIndexName ||
-        typeof options.azureSearchIndexName !== 'string' ||
-        options.azureSearchIndexName.trim() === ''
-      ) {
-        throw new InvalidOptionArgumentError(
-          'Azure Search index name is required and must be a non-empty string.',
-        );
-      }
+    if (args?.includeSearch && !opts.indexName?.trim()) {
+      throw new InvalidOptionArgumentError(
+        'Index name is required. Provide --index-name or set FUSION_AI_INDEX_NAME.',
+      );
     }
   });
 

package/src/setup-framework.ts

@@ -1,107 +1,102 @@
-import { enableAI, type IAIConfigurator, type AIModule } from '@equinor/fusion-framework-module-ai';
-
-import {
-  AzureOpenAiEmbed,
-  AzureOpenAIModel,
-  AzureVectorStore,
-} from '@equinor/fusion-framework-module-ai/azure';
+import { enableAI } from '@equinor/fusion-framework-module-ai';
+import type { AIModule } from '@equinor/fusion-framework-module-ai';
 
+import { initializeFramework, FusionEnv } from '@equinor/fusion-framework-cli/bin';
+import type { FusionFrameworkSettings, FusionFramework } from '@equinor/fusion-framework-cli/bin';
 import type { AiOptions } from './options/index.js';
-import { ModulesConfigurator, type ModulesInstance } from '@equinor/fusion-framework-module';
+
+import { execFileSync } from 'node:child_process';
+
+/** Initialized framework instance with the AI module. */
+export type FrameworkInstance = FusionFramework<[AIModule]>;
 
 /**
- * Framework instance with AI module capabilities.
+ * Check whether an error (possibly wrapped in a cause chain) is an
+ * authentication-related failure that may be recoverable via interactive login.
  *
- * This type represents an initialized Fusion Framework instance that includes
- * the AI module, providing access to chat models, embedding services, and
- * vector stores configured via the setup process.
+ * @internal
  */
-export type FrameworkInstance = ModulesInstance<[AIModule]>;
+const isAuthError = (error: unknown): boolean => {
+  let current: unknown = error;
+  while (current) {
+    if (current instanceof Error) {
+      if (
+        current.name === 'NoAccountsError' ||
+        current.name === 'SilentTokenAcquisitionError' ||
+        current.message.includes('No accounts found')
+      ) {
+        return true;
+      }
+    }
+    current = (current as { cause?: unknown }).cause;
+  }
+  return false;
+};
 
 /**
- * Initializes and configures the Fusion Framework with AI module capabilities.
+ * Creates a Fusion Framework instance with the AI module enabled.
  *
- * Sets up the framework with Azure OpenAI chat models, embedding services, and
- * optionally Azure Cognitive Search vector stores. The function handles the complete
- * initialization process including service registration and dependency injection.
+ * Initialises the Fusion Framework with service discovery and MSAL auth,
+ * resolves the `'ai'` service endpoint, and pre-caches a bearer token.
+ * If MSAL has no cached credentials, the CLI's interactive `auth login`
+ * flow is spawned automatically before retrying.
  *
- * @param options - AI configuration options
- * @param options.openaiApiKey - Azure OpenAI API key for authentication
- * @param options.openaiApiVersion - Azure OpenAI API version (e.g., '2024-02-15-preview')
- * @param options.openaiInstance - Azure OpenAI instance name
- * @param options.openaiChatDeployment - Optional chat model deployment name
- * @param options.openaiEmbeddingDeployment - Optional embedding model deployment name
- * @param options.azureSearchEndpoint - Optional Azure Search service endpoint URL
- * @param options.azureSearchApiKey - Optional Azure Search API key
- * @param options.azureSearchIndexName - Optional Azure Search index name
- * @returns Promise resolving to an initialized framework instance with AI module configured
- * @throws {Error} If embedding deployment is required but not provided when configuring vector store
- * @throws {Error} If embedding service cannot be retrieved for vector store configuration
+ * @param options - CLI options resolved by {@link withOptions}.
+ * @returns A fully initialised framework instance with the AI module.
+ * @throws {Error} When authentication fails after the interactive retry.
  */
-export const setupFramework = async (options: AiOptions): Promise<FrameworkInstance> => {
-  // Create a new module configurator for the framework
-  const configurator = new ModulesConfigurator<[AIModule]>();
+export const setupFramework = async (options: AiOptions): Promise<FusionFramework<[AIModule]>> => {
+  // Service-discovery mode: resolve URL + scopes from Fusion service registry
+  const auth: FusionFrameworkSettings['auth'] = options.token
+    ? { token: options.token }
+    : {
+        tenantId: options.tenantId ?? '3aa4a235-b6e2-48d5-9195-7fcf05b459b0',
+        clientId: options.clientId ?? 'a318b8e1-0295-4e17-98d5-35f67dfeba14',
+      };
 
-  // Configure AI module with provided options
-  enableAI(configurator, (aiConfig: IAIConfigurator) => {
-    // Configure chat model if deployment name is provided
-    if (options.openaiChatDeployment) {
-      aiConfig.setModel(
-        options.openaiChatDeployment,
-        new AzureOpenAIModel({
-          azureOpenAIApiKey: options.openaiApiKey,
-          azureOpenAIApiDeploymentName: options.openaiChatDeployment,
-          azureOpenAIApiInstanceName: options.openaiInstance,
-          azureOpenAIApiVersion: options.openaiApiVersion,
-        }),
-      );
-    }
+  const env = (options.env as FusionEnv) ?? FusionEnv.ContinuesIntegration;
 
-    // Configure embedding model if deployment name is provided
-    if (options.openaiEmbeddingDeployment) {
-      aiConfig.setEmbedding(
-        options.openaiEmbeddingDeployment,
-        new AzureOpenAiEmbed({
-          azureOpenAIApiKey: options.openaiApiKey,
-          azureOpenAIApiDeploymentName: options.openaiEmbeddingDeployment,
-          azureOpenAIApiInstanceName: options.openaiInstance,
-          azureOpenAIApiVersion: options.openaiApiVersion,
-        }),
-      );
-    }
+  /** Initialise the framework, resolve the AI service, and pre-cache tokens. */
+  const initAndSetup = async (): Promise<FusionFramework<[AIModule]>> => {
+    const framework = await initializeFramework<[AIModule]>({ env, auth }, (configurator) => {
+      enableAI(configurator);
+    });
 
-    // Configure vector store if Azure Search options are provided
-    // Vector store requires an embedding service to generate embeddings for documents
-    if (options.azureSearchEndpoint && options.azureSearchApiKey && options.azureSearchIndexName) {
-      if (!options.openaiEmbeddingDeployment) {
-        throw new Error('Embedding deployment is required to configure the vector store');
-      }
+    // resolveService makes an authenticated HTTP call — will throw
+    // NoAccountsError if the user has never logged in.
+    const service = await framework.serviceDiscovery.resolveService('ai');
+    const scopes = service.scopes ?? service.defaultScopes ?? [];
 
-      // Retrieve the embedding service to pass to the vector store
-      // The vector store uses embeddings to index and search documents
-      const embeddingService = aiConfig.getService('embeddings', options.openaiEmbeddingDeployment);
+    // Pre-cache a token for the AI service scopes so strategy callbacks
+    // don't attempt (and fail) a silent acquisition later.
+    const token = await framework.auth.acquireAccessToken({ request: { scopes } });
+    if (!token) throw new Error('Failed to acquire access token for the AI service.');
 
-      // Check that the embedding service was successfully retrieved
-      if (!embeddingService) {
-        throw new Error(
-          `Embedding service '${options.openaiEmbeddingDeployment}' not found for vector store configuration`,
-        );
-      }
+    return framework;
+  };
+
+  try {
+    return await initAndSetup();
+  } catch (error: unknown) {
+    // If the failure is auth-related and we're not using a static token,
+    // spawn the CLI's own `auth login` (starts local server + browser)
+    // and retry the full init sequence.
+    if (!isAuthError(error) || options.token) throw error;
 
-      aiConfig.setVectorStore(
-        options.azureSearchIndexName,
-        new AzureVectorStore(embeddingService, {
-          endpoint: options.azureSearchEndpoint,
-          key: options.azureSearchApiKey,
-          indexName: options.azureSearchIndexName,
-        }),
+    const cliEntry = process.argv[1];
+    if (!cliEntry) {
+      throw new Error(
+        'Failed to acquire access token and could not determine CLI path for interactive login.',
       );
     }
-  });
 
-  // Initialize the framework with all configured modules
-  const framework = await configurator.initialize();
-  return framework;
+    console.log('No cached credentials — launching interactive login…');
+    execFileSync(process.execPath, [cliEntry, 'auth', 'login'], {
+      stdio: 'inherit',
+    });
+
+    return await initAndSetup();
+  }
 };
 
 export default setupFramework;

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '2.0.1';
+export const version = '3.0.0';

package/tsconfig.json

@@ -9,6 +9,9 @@
     "baseUrl": "."
   },
   "references": [
+    {
+      "path": "../../cli"
+    },
     {
       "path": "../../modules/ai"
     },