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

package/dist/types/index.d.ts

@@ -9,5 +9,5 @@
  * @packageDocumentation
  */
 export { type FusionAIConfig, type LoadFusionAIConfigOptions, configureFusionAI, loadFusionAIConfig, } from './config.js';
-export { setupFramework, FrameworkInstance } from './setup-framework.js';
+export { setupFramework, type FrameworkInstance } from './setup-framework.js';
 export { registerAiPlugin } from './register.js';

package/dist/types/options/options.d.ts

@@ -1,87 +1,24 @@
-/**
- * Commander option for the Azure OpenAI API key (`--openai-api-key`).
- *
- * @remarks
- * Required for all Azure OpenAI operations. Falls back to the
- * `AZURE_OPENAI_API_KEY` environment variable when the flag is omitted.
- */
-export declare const apiKeyOption: import("commander").Option;
-/**
- * Commander option for the Azure OpenAI API version (`--openai-api-version`).
- *
- * @remarks
- * Defaults to `2024-02-15-preview`. Falls back to the
- * `AZURE_OPENAI_API_VERSION` environment variable when the flag is omitted.
- */
-export declare const apiVersionOption: import("commander").Option;
-/**
- * Commander option for the Azure OpenAI instance name (`--openai-instance`).
- *
- * @remarks
- * Required for constructing the Azure OpenAI service endpoint. Falls back to
- * the `AZURE_OPENAI_INSTANCE_NAME` environment variable when the flag is omitted.
- */
-export declare const apiInstanceOption: import("commander").Option;
-/**
- * Commander option for the Azure OpenAI chat deployment (`--openai-chat-deployment`).
- *
- * @remarks
- * Required for chat-completion operations. Falls back to the
- * `AZURE_OPENAI_CHAT_DEPLOYMENT_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeChat: true`.
- */
-export declare const chatDeploymentOption: import("commander").Option;
-/**
- * Commander option for the Azure OpenAI embedding deployment (`--openai-embedding-deployment`).
- *
- * @remarks
- * Required for embedding and vector-search operations. Falls back to the
- * `AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeEmbedding: true`.
- */
-export declare const embeddingDeploymentOption: import("commander").Option;
-/**
- * Commander option for the Azure Cognitive Search endpoint (`--azure-search-endpoint`).
- *
- * @remarks
- * Required for vector-search operations. Falls back to the
- * `AZURE_SEARCH_ENDPOINT` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export declare const azureSearchEndpointOption: import("commander").Option;
-/**
- * Commander option for the Azure Cognitive Search API key (`--azure-search-api-key`).
- *
- * @remarks
- * Required for authenticating with Azure Cognitive Search. Falls back to the
- * `AZURE_SEARCH_API_KEY` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export declare const azureSearchApiKeyOption: import("commander").Option;
-/**
- * Commander option for the Azure Cognitive Search index name (`--azure-search-index-name`).
- *
- * @remarks
- * Identifies the target search index to query or write to. Falls back to the
- * `AZURE_SEARCH_INDEX_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export declare const azureSearchIndexNameOption: import("commander").Option;
-/**
- * All AI-related Commander option definitions as a single object.
- *
- * @remarks
- * Use this default export for convenient bulk access when you need every option.
- * For selective inclusion prefer importing the named constants directly.
- */
+/** `--env` | `FUSION_ENV` — Fusion environment for service discovery */
+export declare const envOption: import("commander").Option;
+/** `--token` | `FUSION_TOKEN` — explicit bearer token */
+export declare const tokenOption: import("commander").Option;
+/** `--tenant-id` | `FUSION_TENANT_ID` */
+export declare const tenantIdOption: import("commander").Option;
+/** `--client-id` | `FUSION_CLIENT_ID` */
+export declare const clientIdOption: import("commander").Option;
+/** `--chat-model` | `FUSION_AI_CHAT_MODEL` */
+export declare const chatModelOption: import("commander").Option;
+/** `--embed-model` | `FUSION_AI_EMBED_MODEL` */
+export declare const embedModelOption: import("commander").Option;
+/** `--index-name` | `FUSION_AI_INDEX_NAME` */
+export declare const indexNameOption: import("commander").Option;
 declare const _default: {
-    apiKeyOption: import("commander").Option;
-    apiVersionOption: import("commander").Option;
-    apiInstanceOption: import("commander").Option;
-    chatDeploymentOption: import("commander").Option;
-    embeddingDeploymentOption: import("commander").Option;
-    azureSearchEndpointOption: import("commander").Option;
-    azureSearchApiKeyOption: import("commander").Option;
-    azureSearchIndexNameOption: import("commander").Option;
+    envOption: import("commander").Option;
+    tokenOption: import("commander").Option;
+    tenantIdOption: import("commander").Option;
+    clientIdOption: import("commander").Option;
+    chatModelOption: import("commander").Option;
+    embedModelOption: import("commander").Option;
+    indexNameOption: import("commander").Option;
 };
 export default _default;

package/dist/types/options/schema.d.ts

@@ -1,39 +1,23 @@
-/**
- * Zod validation schema and inferred type for AI command options.
- *
- * @packageDocumentation
- */
 import z from 'zod';
 /**
- * Base Zod schema for AI-related command options.
+ * Base Zod schema for Fusion AI command options.
  *
- * This schema defines the validation rules for all AI options. Other AI plugins
- * can extend this schema to add their own command-specific options.
+ * All fields are optional — when omitted the service URL and token are
+ * resolved automatically from Fusion service discovery and MSAL auth.
  *
  * @example
  * ```ts
- * import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base';
- * import { z } from 'zod';
- *
- * const MyCommandOptionsSchema = AiOptionsSchema.extend({
- *   myOption: z.string(),
- * });
+ * import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+ * const MySchema = AiOptionsSchema.extend({ extra: z.string() });
  * ```
  */
 export declare const AiOptionsSchema: z.ZodObject<{
-    openaiApiKey: z.ZodString;
-    openaiApiVersion: z.ZodString;
-    openaiInstance: z.ZodString;
-    openaiChatDeployment: z.ZodOptional<z.ZodString>;
-    openaiEmbeddingDeployment: z.ZodOptional<z.ZodString>;
-    azureSearchEndpoint: z.ZodOptional<z.ZodString>;
-    azureSearchApiKey: z.ZodOptional<z.ZodString>;
-    azureSearchIndexName: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    chatModel: z.ZodOptional<z.ZodString>;
+    embedModel: z.ZodOptional<z.ZodString>;
+    indexName: z.ZodOptional<z.ZodString>;
 }, z.z.core.$strip>;
-/**
- * Type representing the validated AI options.
- *
- * This type is inferred from the Zod schema and should be used throughout AI plugins
- * to ensure type safety and consistency with the schema.
- */
 export type AiOptionsType = z.infer<typeof AiOptionsSchema>;

package/dist/types/options/types.d.ts

@@ -1,41 +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/dist/types/options/with-options.d.ts

@@ -1,37 +1,24 @@
 import { type Command } from 'commander';
 /**
- * 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 declare const withOptions: (command: Command, args?: Partial<{
-    includeEmbedding: boolean;
     includeChat: boolean;
+    includeEmbedding: boolean;
     includeSearch: boolean;
 }>) => Command;
 export default withOptions;

package/dist/types/setup-framework.d.ts

@@ -1,33 +1,19 @@
-import { type AIModule } from '@equinor/fusion-framework-module-ai';
+import type { AIModule } from '@equinor/fusion-framework-module-ai';
+import type { FusionFramework } from '@equinor/fusion-framework-cli/bin';
 import type { AiOptions } from './options/index.js';
-import { type ModulesInstance } from '@equinor/fusion-framework-module';
+/** Initialized framework instance with the AI module. */
+export type FrameworkInstance = FusionFramework<[AIModule]>;
 /**
- * Framework instance with AI module capabilities.
+ * Creates a Fusion Framework instance with the AI module enabled.
  *
- * 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.
- */
-export type FrameworkInstance = ModulesInstance<[AIModule]>;
-/**
- * Initializes and configures the Fusion Framework with AI module capabilities.
- *
- * 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 declare const setupFramework: (options: AiOptions) => Promise<FrameworkInstance>;
+export declare const setupFramework: (options: AiOptions) => Promise<FusionFramework<[AIModule]>>;
 export default setupFramework;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.0.1";
+export declare const version = "3.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-cli-plugin-ai-base",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Base AI plugin package for Fusion Framework CLI",
   "type": "module",
   "main": "dist/esm/index.js",
@@ -46,16 +46,16 @@
     "commander": "^14.0.1",
     "zod": "^4.3.6",
     "@equinor/fusion-framework-module": "6.0.0",
-    "@equinor/fusion-framework-module-ai": "3.0.1",
-    "@equinor/fusion-imports": "2.0.0"
+    "@equinor/fusion-imports": "2.0.0",
+    "@equinor/fusion-framework-module-ai": "4.0.0"
   },
   "peerDependencies": {
-    "@equinor/fusion-framework-cli": "^14.2.5"
+    "@equinor/fusion-framework-cli": "^14.2.7"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "vitest": "^4.1.0",
-    "@equinor/fusion-framework-cli": "^14.2.5"
+    "@equinor/fusion-framework-cli": "^14.2.7"
   },
   "scripts": {
     "build": "tsc -b",

package/src/index.ts

@@ -15,5 +15,5 @@ export {
   configureFusionAI,
   loadFusionAIConfig,
 } from './config.js';
-export { setupFramework, FrameworkInstance } from './setup-framework.js';
+export { setupFramework, type FrameworkInstance } from './setup-framework.js';
 export { registerAiPlugin } from './register.js';

package/src/options/options.ts

@@ -1,122 +1,62 @@
 import { createOption } from 'commander';
 
-/**
- * Commander option for the Azure OpenAI API key (`--openai-api-key`).
- *
- * @remarks
- * Required for all Azure OpenAI operations. Falls back to the
- * `AZURE_OPENAI_API_KEY` environment variable when the flag is omitted.
- */
-export const apiKeyOption = createOption(
-  '--openai-api-key <key>',
-  'API key for Azure OpenAI services',
-).env('AZURE_OPENAI_API_KEY');
-
-/**
- * Commander option for the Azure OpenAI API version (`--openai-api-version`).
- *
- * @remarks
- * Defaults to `2024-02-15-preview`. Falls back to the
- * `AZURE_OPENAI_API_VERSION` environment variable when the flag is omitted.
- */
-export const apiVersionOption = createOption(
-  '--openai-api-version <version>',
-  'Azure OpenAI API version',
+// Default Fusion AAD identifiers (same defaults as the CLI's auth options)
+const DEFAULT_TENANT_ID = '3aa4a235-b6e2-48d5-9195-7fcf05b459b0' as const;
+const DEFAULT_CLIENT_ID = 'a318b8e1-0295-4e17-98d5-35f67dfeba14' as const;
+const DEFAULT_MODEL_CHAT = 'gpt-5.1-chat' as const;
+const DEFAULT_MODEL_EMBED = 'text-embedding-3-large' as const;
+
+/** `--env` | `FUSION_ENV` — Fusion environment for service discovery */
+export const envOption = createOption('--env <env>', 'Fusion environment for service discovery')
+  .env('FUSION_ENV')
+  .default('ci');
+
+/** `--token` | `FUSION_TOKEN` — explicit bearer token */
+export const tokenOption = createOption(
+  '--token <token>',
+  'Azure AD bearer token (skips interactive/silent MSAL auth)',
 )
-  .env('AZURE_OPENAI_API_VERSION')
-  .default('2024-02-15-preview');
-
-/**
- * Commander option for the Azure OpenAI instance name (`--openai-instance`).
- *
- * @remarks
- * Required for constructing the Azure OpenAI service endpoint. Falls back to
- * the `AZURE_OPENAI_INSTANCE_NAME` environment variable when the flag is omitted.
- */
-export const apiInstanceOption = createOption(
-  '--openai-instance <name>',
-  'Azure OpenAI instance name',
-).env('AZURE_OPENAI_INSTANCE_NAME');
-
-/**
- * Commander option for the Azure OpenAI chat deployment (`--openai-chat-deployment`).
- *
- * @remarks
- * Required for chat-completion operations. Falls back to the
- * `AZURE_OPENAI_CHAT_DEPLOYMENT_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeChat: true`.
- */
-export const chatDeploymentOption = createOption(
-  '--openai-chat-deployment <name>',
-  'Azure OpenAI chat deployment name',
-).env('AZURE_OPENAI_CHAT_DEPLOYMENT_NAME');
-
-/**
- * Commander option for the Azure OpenAI embedding deployment (`--openai-embedding-deployment`).
- *
- * @remarks
- * Required for embedding and vector-search operations. Falls back to the
- * `AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeEmbedding: true`.
- */
-export const embeddingDeploymentOption = createOption(
-  '--openai-embedding-deployment <name>',
-  'Azure OpenAI embedding deployment name',
-).env('AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME');
-
-/**
- * Commander option for the Azure Cognitive Search endpoint (`--azure-search-endpoint`).
- *
- * @remarks
- * Required for vector-search operations. Falls back to the
- * `AZURE_SEARCH_ENDPOINT` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export const azureSearchEndpointOption = createOption(
-  '--azure-search-endpoint <url>',
-  'Azure Search endpoint URL',
-).env('AZURE_SEARCH_ENDPOINT');
+  .env('FUSION_TOKEN')
+  .default(undefined);
+
+/** `--tenant-id` | `FUSION_TENANT_ID` */
+export const tenantIdOption = createOption('--tenant-id <id>', 'Azure AD tenant ID')
+  .env('FUSION_TENANT_ID')
+  .default(DEFAULT_TENANT_ID);
+
+/** `--client-id` | `FUSION_CLIENT_ID` */
+export const clientIdOption = createOption('--client-id <id>', 'Azure AD application client ID')
+  .env('FUSION_CLIENT_ID')
+  .default(DEFAULT_CLIENT_ID);
+
+/** `--chat-model` | `FUSION_AI_CHAT_MODEL` */
+export const chatModelOption = createOption(
+  '--chat-model <name>',
+  'Azure OpenAI chat model deployment name',
+)
+  .env('FUSION_AI_CHAT_MODEL')
+  .default(DEFAULT_MODEL_CHAT);
 
-/**
- * Commander option for the Azure Cognitive Search API key (`--azure-search-api-key`).
- *
- * @remarks
- * Required for authenticating with Azure Cognitive Search. Falls back to the
- * `AZURE_SEARCH_API_KEY` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export const azureSearchApiKeyOption = createOption(
-  '--azure-search-api-key <key>',
-  'Azure Search API key',
-).env('AZURE_SEARCH_API_KEY');
+/** `--embed-model` | `FUSION_AI_EMBED_MODEL` */
+export const embedModelOption = createOption(
+  '--embed-model <name>',
+  'Azure OpenAI embedding model deployment name',
+)
+  .env('FUSION_AI_EMBED_MODEL')
+  .default(DEFAULT_MODEL_EMBED);
 
-/**
- * Commander option for the Azure Cognitive Search index name (`--azure-search-index-name`).
- *
- * @remarks
- * Identifies the target search index to query or write to. Falls back to the
- * `AZURE_SEARCH_INDEX_NAME` environment variable when the flag is omitted.
- * Only added to a command when `withOptions` is called with `includeSearch: true`.
- */
-export const azureSearchIndexNameOption = createOption(
-  '--azure-search-index-name <name>',
-  'Azure Search index name',
-).env('AZURE_SEARCH_INDEX_NAME');
+/** `--index-name` | `FUSION_AI_INDEX_NAME` */
+export const indexNameOption = createOption(
+  '--index-name <name>',
+  'Azure AI Search index name',
+).env('FUSION_AI_INDEX_NAME');
 
-/**
- * All AI-related Commander option definitions as a single object.
- *
- * @remarks
- * Use this default export for convenient bulk access when you need every option.
- * For selective inclusion prefer importing the named constants directly.
- */
 export default {
-  apiKeyOption,
-  apiVersionOption,
-  apiInstanceOption,
-  chatDeploymentOption,
-  embeddingDeploymentOption,
-  azureSearchEndpointOption,
-  azureSearchApiKeyOption,
-  azureSearchIndexNameOption,
+  envOption,
+  tokenOption,
+  tenantIdOption,
+  clientIdOption,
+  chatModelOption,
+  embedModelOption,
+  indexNameOption,
 };

package/src/options/schema.ts

@@ -1,77 +1,27 @@
-/**
- * Zod validation schema and inferred type for AI command options.
- *
- * @packageDocumentation
- */
-
 import z from 'zod';
 
 /**
- * Base Zod schema for AI-related command options.
+ * Base Zod schema for Fusion AI command options.
  *
- * This schema defines the validation rules for all AI options. Other AI plugins
- * can extend this schema to add their own command-specific options.
+ * All fields are optional — when omitted the service URL and token are
+ * resolved automatically from Fusion service discovery and MSAL auth.
  *
  * @example
  * ```ts
- * import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base';
- * import { z } from 'zod';
- *
- * const MyCommandOptionsSchema = AiOptionsSchema.extend({
- *   myOption: z.string(),
- * });
+ * import { AiOptionsSchema } from '@equinor/fusion-framework-cli-plugin-ai-base/command-options';
+ * const MySchema = AiOptionsSchema.extend({ extra: z.string() });
  * ```
  */
 export const AiOptionsSchema = z
   .object({
-    // Required AI options
-    openaiApiKey: z
-      .string({ message: 'Azure OpenAI API key is required and must be a non-empty string.' })
-      .min(1, 'API key must be a non-empty string.')
-      .describe('Azure OpenAI API key for authentication'),
-    openaiApiVersion: z
-      .string({ message: 'Azure OpenAI API version is required and must be a non-empty string.' })
-      .min(1, 'API version must be a non-empty string.')
-      .describe('Azure OpenAI API version'),
-    openaiInstance: z
-      .string({ message: 'Azure OpenAI instance name is required and must be a non-empty string.' })
-      .min(1, 'Instance name must be a non-empty string.')
-      .describe('Azure OpenAI instance name'),
-
-    // Optional AI options
-    openaiChatDeployment: z
-      .string()
-      .min(1, 'Chat deployment name must be a non-empty string.')
-      .optional()
-      .describe('Azure OpenAI chat deployment name'),
-    openaiEmbeddingDeployment: z
-      .string()
-      .min(1, 'Embedding deployment name must be a non-empty string.')
-      .optional()
-      .describe('Azure OpenAI embedding deployment name'),
-    azureSearchEndpoint: z
-      .string()
-      .url('Azure Search endpoint must be a valid URL.')
-      .min(1, 'Azure Search endpoint must be a non-empty string.')
-      .optional()
-      .describe('Azure Search endpoint URL'),
-    azureSearchApiKey: z
-      .string()
-      .min(1, 'Azure Search API key must be a non-empty string.')
-      .optional()
-      .describe('Azure Search API key'),
-    azureSearchIndexName: z
-      .string()
-      .min(1, 'Azure Search index name must be a non-empty string.')
-      .optional()
-      .describe('Azure Search index name'),
+    env: z.string().optional(),
+    token: z.string().optional(),
+    tenantId: z.string().optional(),
+    clientId: z.string().optional(),
+    chatModel: z.string().min(1).optional(),
+    embedModel: z.string().min(1).optional(),
+    indexName: z.string().min(1).optional(),
   })
-  .describe('Base AI-related command options');
+  .describe('Base Fusion AI command options');
 
-/**
- * Type representing the validated AI options.
- *
- * This type is inferred from the Zod schema and should be used throughout AI plugins
- * to ensure type safety and consistency with the schema.
- */
 export type AiOptionsType = z.infer<typeof AiOptionsSchema>;