codemie-sdk 0.1.64

package/dist/index.cjs

@@ -0,0 +1,1357 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AssistantChatParamsSchema: () => AssistantChatParamsSchema,
+  AssistantCreateParamsSchema: () => AssistantCreateParamsSchema,
+  AssistantListParamsSchema: () => AssistantListParamsSchema,
+  AssistantUpdateParamsSchema: () => AssistantUpdateParamsSchema,
+  BackgroundTaskStatus: () => BackgroundTaskStatus,
+  ChatRole: () => ChatRole,
+  CodeDataSourceType: () => CodeDataSourceType,
+  CodeMieClient: () => CodeMieClient,
+  CodeMieError: () => CodeMieError,
+  ContextType: () => ContextType,
+  CredentialTypes: () => CredentialTypes,
+  DataSourceStatus: () => DataSourceStatus,
+  DataSourceType: () => DataSourceType,
+  ExecutionStatus: () => ExecutionStatus,
+  IntegrationCreateParamsSchema: () => IntegrationCreateParamsSchema,
+  IntegrationGetByAliasParamsSchema: () => IntegrationGetByAliasParamsSchema,
+  IntegrationGetParamsSchema: () => IntegrationGetParamsSchema,
+  IntegrationListParamsSchema: () => IntegrationListParamsSchema,
+  IntegrationType: () => IntegrationType,
+  IntegrationUpdateParamsSchema: () => IntegrationUpdateParamsSchema,
+  LLMProvider: () => LLMProvider,
+  NotFoundError: () => NotFoundError,
+  WorkflowCreateParamsSchema: () => WorkflowCreateParamsSchema,
+  WorkflowExecutionCreateParamsSchema: () => WorkflowExecutionCreateParamsSchema,
+  WorkflowExecutionListParamsSchema: () => WorkflowExecutionListParamsSchema,
+  WorkflowExecutionStateListParamsSchema: () => WorkflowExecutionStateListParamsSchema,
+  WorkflowListParamsSchema: () => WorkflowListParamsSchema,
+  WorkflowMode: () => WorkflowMode,
+  WorkflowUpdateParamsSchema: () => WorkflowUpdateParamsSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/auth/credentials.ts
+var import_node_https = require("https");
+var import_axios = __toESM(require("axios"), 1);
+var DEFAULT_CLIENT_ID = "codemie-sdk";
+var KeycloakCredentials = class {
+  constructor(config) {
+    this.validateConfigCredentials(config);
+    this.config = config;
+    this.httpAgent = new import_node_https.Agent({
+      rejectUnauthorized: config.verifySSL
+    });
+  }
+  async getToken() {
+    const { serverUrl, realmName } = this.config;
+    const url = `${serverUrl}/realms/${realmName}/protocol/openid-connect/token`;
+    const payload = this.config.username && this.config.password ? this.createResourceOwnerCredentialsPayload() : this.createClientCredentialsPayload();
+    const { data } = await import_axios.default.post(url, this.createSearchParams(payload), {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      httpsAgent: this.httpAgent
+    });
+    return data.access_token;
+  }
+  createResourceOwnerCredentialsPayload() {
+    const { username, password, clientId } = this.config;
+    return {
+      grant_type: "password",
+      username,
+      password,
+      client_id: clientId || DEFAULT_CLIENT_ID
+    };
+  }
+  createClientCredentialsPayload() {
+    const { clientId, clientSecret } = this.config;
+    return {
+      grant_type: "client_credentials",
+      client_id: clientId || DEFAULT_CLIENT_ID,
+      client_secret: clientSecret
+    };
+  }
+  createSearchParams(payload) {
+    return new URLSearchParams(
+      Object.fromEntries(Object.entries(payload).filter(([_, v]) => v !== void 0))
+    );
+  }
+  validateConfigCredentials(config) {
+    if (!(config.clientId && config.clientSecret || config.username && config.password)) {
+      throw new Error(
+        "Either client credentials (clientId, clientSecret) or user credentials (username, password) must be provided"
+      );
+    }
+  }
+};
+
+// src/utils/helpers.ts
+function omitUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== void 0));
+}
+
+// src/mappers/assistant.mapper.ts
+var AssistantMapper = class {
+  static mapBaseModelApiResponse(response) {
+    return omitUndefined({
+      generated: response.generated,
+      time_elapsed: response.timeElapsed,
+      tokens_used: response.tokensUsed,
+      thoughts: response.thoughts,
+      task_id: response.taskId
+    });
+  }
+};
+
+// src/schemas/assistant.ts
+var import_zod = require("zod");
+var AssistantListParamsSchema = import_zod.z.object({
+  minimal_response: import_zod.z.boolean().default(true),
+  scope: import_zod.z.enum(["visible_to_user", "created_by_user"]).default("visible_to_user"),
+  page: import_zod.z.number().default(0),
+  per_page: import_zod.z.number().default(12),
+  filters: import_zod.z.record(import_zod.z.unknown()).optional()
+}).readonly();
+var AssistantCreateParamsSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string(),
+  icon_url: import_zod.z.string().optional(),
+  system_prompt: import_zod.z.string(),
+  project: import_zod.z.string(),
+  context: import_zod.z.array(
+    import_zod.z.object({
+      context_type: import_zod.z.enum(["knowledge_base", "code"]),
+      name: import_zod.z.string()
+    })
+  ),
+  llm_model_type: import_zod.z.string(),
+  toolkits: import_zod.z.array(
+    import_zod.z.object({
+      toolkit: import_zod.z.string(),
+      tools: import_zod.z.array(
+        import_zod.z.object({
+          name: import_zod.z.string(),
+          label: import_zod.z.string().optional(),
+          settings_config: import_zod.z.boolean(),
+          user_description: import_zod.z.string().optional(),
+          settings: import_zod.z.any().nullable().optional()
+        })
+      ),
+      label: import_zod.z.string(),
+      settings_config: import_zod.z.boolean(),
+      is_external: import_zod.z.boolean(),
+      settings: import_zod.z.any().optional()
+    })
+  ),
+  user_prompts: import_zod.z.array(import_zod.z.string()),
+  shared: import_zod.z.boolean().optional(),
+  is_react: import_zod.z.boolean().optional(),
+  is_global: import_zod.z.boolean().optional(),
+  slug: import_zod.z.string().optional(),
+  temperature: import_zod.z.number().optional(),
+  top_p: import_zod.z.number().optional(),
+  mcp_servers: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      description: import_zod.z.string().optional(),
+      enabled: import_zod.z.boolean(),
+      config: import_zod.z.object({
+        command: import_zod.z.string(),
+        args: import_zod.z.array(import_zod.z.string()).optional(),
+        env: import_zod.z.record(import_zod.z.unknown()).optional(),
+        auth_token: import_zod.z.string().optional()
+      }).optional(),
+      mcp_connect_url: import_zod.z.string().optional(),
+      tools_tokens_size_limit: import_zod.z.number().optional(),
+      command: import_zod.z.string().optional(),
+      arguments: import_zod.z.string().optional(),
+      settings: import_zod.z.any().optional(),
+      mcp_connect_auth_token: import_zod.z.any().optional()
+    })
+  ),
+  assistant_ids: import_zod.z.array(import_zod.z.string())
+}).readonly();
+var AssistantUpdateParamsSchema = AssistantCreateParamsSchema;
+var AssistantChatParamsSchema = import_zod.z.object({
+  conversation_id: import_zod.z.string().optional(),
+  text: import_zod.z.string(),
+  content_raw: import_zod.z.string().optional(),
+  file_name: import_zod.z.string().optional(),
+  llm_model: import_zod.z.string().optional(),
+  history: import_zod.z.union([
+    import_zod.z.array(
+      import_zod.z.object({
+        role: import_zod.z.enum(["Assistant", "User"]),
+        message: import_zod.z.string().optional()
+      })
+    ),
+    import_zod.z.string()
+  ]),
+  history_index: import_zod.z.number().optional(),
+  stream: import_zod.z.boolean().optional(),
+  top_k: import_zod.z.number().optional(),
+  system_prompt: import_zod.z.string().optional(),
+  background_task: import_zod.z.boolean().optional(),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+}).readonly();
+
+// src/utils/http.ts
+var import_node_https2 = require("https");
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/exceptions/exceptions.ts
+var CodeMieError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodeMieError";
+  }
+};
+var ApiError = class extends CodeMieError {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(resourceType, resourceId) {
+    super(`${resourceType} with ${resourceId} not found`, 404);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/utils/http.ts
+var ApiRequestHandler = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.client = import_axios2.default.create({
+      baseURL: apiDomain.replace(/\/$/, ""),
+      // Remove trailing slash
+      validateStatus: (status) => status < 400,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      httpsAgent: new import_node_https2.Agent({
+        rejectUnauthorized: verifySSL
+      })
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => this.processFailedResponse(error)
+    );
+  }
+  async request(method, path, config = {}) {
+    const response = await this.client.request({
+      method,
+      url: path,
+      ...config
+    });
+    return response.data;
+  }
+  async get(path, params, config = {}) {
+    return this.request("get", path, { ...config, params });
+  }
+  async post(path, data, config = {}) {
+    return this.request("post", path, { ...config, data });
+  }
+  async postMultipart(url, formData, params) {
+    const response = await this.client.post(url, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      },
+      params
+    });
+    return response.data;
+  }
+  async put(path, data, config = {}) {
+    return this.request("put", path, { ...config, data });
+  }
+  async delete(path, config = {}) {
+    return this.request("delete", path, config);
+  }
+  async stream(path, data, config = {}) {
+    return this.client.post(path, data, {
+      ...config,
+      responseType: "stream"
+    });
+  }
+  processFailedResponse(error) {
+    const response = error.response;
+    const status = response?.status || 500;
+    const data = response?.data || {};
+    if (status === 404) {
+      throw new NotFoundError("Resource", "unknown");
+    }
+    if (status === 422) {
+      const errorMessage2 = [
+        data.error?.message,
+        data.error?.help,
+        JSON.stringify(data.error?.details ?? {})
+      ].filter(Boolean).join(". ");
+      throw new ApiError(errorMessage2 || "Validation error", status, data);
+    }
+    const errorMessage = [data.error?.message, data.error?.detail, data.error?.help].filter(Boolean).join(". ");
+    throw new ApiError(errorMessage, status, data);
+  }
+};
+
+// src/services/assistant.ts
+var AssistantService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get list of available assistants.
+   */
+  async list(_params = {}) {
+    const params = AssistantListParamsSchema.parse(_params);
+    const response = await this.api.get(
+      "/v1/assistants",
+      {
+        ...params,
+        ...params.filters && { filters: JSON.stringify(params.filters) }
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Get assistant by ID.
+   */
+  async get(assistantId) {
+    return this.api.get(`/v1/assistants/id/${assistantId}`);
+  }
+  /**
+   * Get assistant by slug.
+   */
+  async getBySlug(slug) {
+    return this.api.get(`/v1/assistants/slug/${slug}`);
+  }
+  /**
+   * Create a new assistant.
+   */
+  async create(_params) {
+    const params = AssistantCreateParamsSchema.parse(_params);
+    return this.api.post("/v1/assistants", params);
+  }
+  /**
+   * Update an existing assistant.
+   */
+  async update(assistantId, _params) {
+    const params = AssistantUpdateParamsSchema.parse(_params);
+    return this.api.put(`/v1/assistants/${assistantId}`, params);
+  }
+  /**
+   * Get list of available tools.
+   */
+  async getTools() {
+    return this.api.get("/v1/assistants/tools");
+  }
+  /**
+   * Delete an assistant by ID.
+   */
+  async delete(assistantId) {
+    return this.api.delete(`/v1/assistants/${assistantId}`);
+  }
+  /**
+   * Get list of prebuilt assistants.
+   */
+  async getPrebuilt() {
+    return this.api.get("/v1/assistants/prebuilt");
+  }
+  /**
+   * Get prebuilt assistant by slug.
+   */
+  async getPrebuiltBySlug(slug) {
+    return this.api.get(`/v1/assistants/prebuilt/${slug}`);
+  }
+  /**
+   * Send a chat request to an assistant.
+   */
+  async chat(assistantId, _params) {
+    const params = AssistantChatParamsSchema.parse(_params);
+    const response = await this.api.post(
+      `/v1/assistants/${assistantId}/model`,
+      params,
+      {
+        responseType: params.stream ? "stream" : void 0
+      }
+    );
+    return AssistantMapper.mapBaseModelApiResponse(response);
+  }
+};
+
+// src/services/datasource.ts
+var import_form_data = __toESM(require("form-data"), 1);
+
+// src/models/datasource.ts
+var CodeDataSourceType = {
+  CODE: "code",
+  SUMMARY: "summary",
+  CHUNK_SUMMARY: "chunk-summary"
+};
+var DataSourceType = {
+  CODE: "code",
+  CONFLUENCE: "knowledge_base_confluence",
+  JIRA: "knowledge_base_jira",
+  FILE: "knowledge_base_file",
+  GOOGLE: "llm_routing_google",
+  PROVIDER: "provider",
+  SUMMARY: "summary",
+  CHUNK_SUMMARY: "chunk-summary",
+  JSON: "knowledge_base_json"
+};
+var DataSourceStatus = {
+  COMPLETED: "completed",
+  FAILED: "failed",
+  FETCHING: "fetching",
+  IN_PROGRESS: "in_progress"
+};
+
+// src/mappers/datasource.mapper.ts
+var DatasourceMapper = class _DatasourceMapper {
+  /** Transforms API response into a client-friendly DataSource model, maintaining API-agnostic interface */
+  static mapDatasourceResponse(response) {
+    return omitUndefined({
+      id: response.id,
+      project_name: response.project_name,
+      name: response.repo_name,
+      description: response.description,
+      type: response.index_type,
+      embeddings_model: response.embeddings_model,
+      status: response.status,
+      setting_id: response.setting_id,
+      created_date: response.date,
+      created_by: response.created_by,
+      shared_with_project: response.project_space_visible,
+      update_date: response.update_date,
+      error_message: response.text,
+      user_abilities: response.user_abilities,
+      processing_info: response.processing_info ? _DatasourceMapper.mapDatasourceProcessingInfoResponse(response.processing_info) : void 0,
+      processed_documents: response.processed_files,
+      tokens_usage: response.tokens_usage,
+      code: response.code,
+      jira: response.jira,
+      confluence: response.confluence,
+      google_doc_link: response.google_doc_link
+    });
+  }
+  /** Converts processing metadata from API format to client model format with consistent property naming */
+  static mapDatasourceProcessingInfoResponse(response) {
+    return omitUndefined({
+      total_documents_count: response.total_documents,
+      skipped_documents_count: response.skipped_documents,
+      total_size_kb: response.total_size_kb,
+      average_file_size_bytes: response.average_file_size_bytes,
+      unique_extensions: response.unique_extensions,
+      filtered_documents: response.filtered_documents,
+      processed_documents_count: response.documents_count_key
+    });
+  }
+  /** Transforms datasource creation parameters into DTO format, applying type-specific mappings based on datasource type */
+  static mapDatasourceCreateToDto(create) {
+    return omitUndefined({
+      ..._DatasourceMapper.mapCommonDataSourceParams(create),
+      ...create.type === DataSourceType.CONFLUENCE && _DatasourceMapper.mapConfluenceDataSourceParams(create),
+      ...create.type === DataSourceType.JIRA && _DatasourceMapper.mapJiraDataSourceParams(create),
+      ...create.type === DataSourceType.GOOGLE && _DatasourceMapper.mapGoogleDataSourceParams(create),
+      ...create.type === DataSourceType.FILE && _DatasourceMapper.mapFileDataSourceParams(create),
+      ...create.type === DataSourceType.CODE && _DatasourceMapper.mapCodeDataSourceParams(create)
+    });
+  }
+  /** Converts datasource update parameters to DTO format with conditional inclusion of type-specific properties */
+  static mapDatasourceUpdateToDto(update) {
+    return omitUndefined({
+      ..._DatasourceMapper.mapCommonUpdateDataSourceParams(update),
+      ...update.type === DataSourceType.CONFLUENCE && _DatasourceMapper.mapConfluenceDataSourceParams(update),
+      ...update.type === DataSourceType.JIRA && _DatasourceMapper.mapJiraDataSourceParams(update),
+      ...update.type === DataSourceType.GOOGLE && _DatasourceMapper.mapGoogleDataSourceParams(update),
+      ...update.type === DataSourceType.FILE && _DatasourceMapper.mapFileDataSourceParams(update),
+      ...update.type === DataSourceType.CODE && _DatasourceMapper.mapCodeDataSourceParams(update)
+    });
+  }
+  /** Maps Confluence-specific configuration parameters for content filtering and pagination options */
+  static mapConfluenceDataSourceParams(params) {
+    return {
+      cql: params.cql,
+      include_restricted_content: params.include_restricted_content,
+      include_archived_content: params.include_archived_content,
+      include_attachments: params.include_attachments,
+      include_comments: params.include_comments,
+      keep_markdown_format: params.keep_markdown_format,
+      keep_newlines: params.keep_newlines,
+      max_pages: params.max_pages,
+      pages_per_request: params.pages_per_request
+    };
+  }
+  /** Maps Jira-specific parameters, transforming JQL (Jira Query Language) filter configuration */
+  static mapJiraDataSourceParams(params) {
+    return {
+      jql: params.jql
+    };
+  }
+  /** Maps Google Doc specific parameters with proper API naming conventions */
+  static mapGoogleDataSourceParams(params) {
+    return {
+      googleDoc: params.google_doc
+    };
+  }
+  /** Maps file upload datasource parameters, handling file reference collections */
+  static mapFileDataSourceParams(params) {
+    return {
+      files: params.files
+    };
+  }
+  /** Maps code repository specific parameters including indexing strategy and code processing settings */
+  static mapCodeDataSourceParams(params) {
+    return {
+      settingId: params.setting_id,
+      projectSpaceVisible: params.shared_with_project || false,
+      link: params.link,
+      branch: params.branch,
+      indexType: params.index_type,
+      filesFilter: params.files_filter,
+      embeddingsModel: params.embeddings_model,
+      summarizationModel: params.summarization_model,
+      prompt: params.prompt,
+      docsGeneration: params.docs_generation || false
+    };
+  }
+  /** Maps general datasource parameters common across all datasource types with appropriate fallback values */
+  static mapCommonDataSourceParams(params) {
+    return {
+      name: params.name,
+      project_name: params.project_name,
+      description: params.description,
+      project_space_visible: params.shared_with_project || false,
+      setting_id: params.setting_id || null,
+      type: params.type
+    };
+  }
+  static mapCommonUpdateDataSourceParams(params) {
+    return omitUndefined({
+      name: params.name,
+      project_name: params.project_name,
+      description: params.description,
+      project_space_visible: params.shared_with_project || false,
+      setting_id: params.setting_id || null,
+      type: params.type
+    });
+  }
+};
+
+// src/services/datasource.ts
+var DATA_SOURCE_TO_PATH_PARAM = {
+  [DataSourceType.CODE]: "CODE",
+  [DataSourceType.CONFLUENCE]: "CONFLUENCE",
+  [DataSourceType.JIRA]: "JIRA",
+  [DataSourceType.FILE]: "FILE",
+  [DataSourceType.GOOGLE]: "GOOGLE",
+  [DataSourceType.PROVIDER]: "PROVIDER",
+  [DataSourceType.SUMMARY]: "SUMMARY",
+  [DataSourceType.CHUNK_SUMMARY]: "CHUNK_SUMMARY",
+  [DataSourceType.JSON]: "JSON"
+};
+var DatasourceService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Create a new datasource.
+   */
+  async create(params) {
+    const dto = DatasourceMapper.mapDatasourceCreateToDto(params);
+    if (dto.type === DataSourceType.FILE) {
+      return this.createFileDatasource(dto);
+    }
+    return this.api.post(this.getCreateDatasourceUrl(dto.type, dto.project_name), dto);
+  }
+  /**
+   * Create a file datasource.
+   */
+  async createFileDatasource({
+    files,
+    ...datasource
+  }) {
+    const formData = new import_form_data.default();
+    for (const file of files) {
+      formData.append("files", Buffer.from(file.content), {
+        filename: file.name,
+        contentType: file.mime_type
+      });
+    }
+    return this.api.postMultipart(
+      this.getCreateDatasourceUrl(datasource.type, datasource.project_name),
+      formData,
+      datasource
+    );
+  }
+  /**
+   * Update an existing datasource.
+   */
+  async update(params) {
+    this.validateUpdateReindexParams(params);
+    const { full_reindex, skip_reindex, resume_indexing, incremental_reindex, ...data } = params;
+    const endpoint = params.type === DataSourceType.CODE ? `/v1/application/${params.project_name}/index/${params.name}` : `/v1/index/knowledge_base/${this.getKnowledgeBaseParam(params.type)}`;
+    const queryParams = {
+      full_reindex,
+      skip_reindex,
+      resume_indexing,
+      incremental_reindex
+    };
+    const { type, ...dto } = DatasourceMapper.mapDatasourceUpdateToDto(data);
+    return this.api.put(endpoint, dto, { params: queryParams });
+  }
+  /**
+   * List datasources with pagination and filtering support.
+   */
+  async list(params = {}) {
+    const queryParams = {
+      page: params.page || 0,
+      per_page: params.per_page || 10,
+      sort_key: params.sort_key || "update_date",
+      sort_order: params.sort_order || "desc"
+    };
+    if (params.datasource_types || params.projects || params.status || params.owner) {
+      const filters = {};
+      if (params.datasource_types) filters.index_type = params.datasource_types;
+      if (params.projects) filters.project = params.projects;
+      if (params.status) filters.status = params.status;
+      if (params.owner) filters.created_by = params.owner;
+      queryParams.filters = JSON.stringify(filters);
+    }
+    const response = await this.api.get(
+      "/v1/index",
+      queryParams
+    );
+    return response.data.map(DatasourceMapper.mapDatasourceResponse);
+  }
+  /**
+   * Get datasource by ID.
+   */
+  async get(datasourceId) {
+    const response = await this.api.get(`/v1/index/${datasourceId}`);
+    return DatasourceMapper.mapDatasourceResponse(response);
+  }
+  /**
+   * Delete a datasource by ID.
+   */
+  async delete(datasourceId) {
+    return this.api.delete(`/v1/index/${datasourceId}`);
+  }
+  getCreateDatasourceUrl(type, projectName) {
+    if (type === DataSourceType.CODE) {
+      return `/v1/application/${projectName}/index`;
+    }
+    return `/v1/index/knowledge_base/${this.getKnowledgeBaseParam(type)}`;
+  }
+  getKnowledgeBaseParam(type) {
+    return DATA_SOURCE_TO_PATH_PARAM[type].toLowerCase();
+  }
+  /**
+   * Validates update parameters for reindexing.
+   * @throws {Error} If the update parameters are invalid for the given datasource type.
+   */
+  validateUpdateReindexParams(updateParams) {
+    if (updateParams.type === DataSourceType.CONFLUENCE && updateParams.incremental_reindex) {
+      throw new Error("Confluence data sources only support full_reindex and resume_indexing");
+    }
+    if (updateParams.type === DataSourceType.JIRA && updateParams.resume_indexing) {
+      throw new Error("Jira data sources only support full_reindex and incremental_reindex");
+    }
+    if (updateParams.type === DataSourceType.CODE && updateParams.incremental_reindex) {
+      throw new Error("Code data sources do not support incremental_reindex");
+    }
+    if (updateParams.type === DataSourceType.GOOGLE && updateParams.incremental_reindex) {
+      throw new Error("Google data sources only support full_reindex");
+    }
+  }
+};
+
+// src/models/integration.ts
+var CredentialTypes = {
+  JIRA: "Jira",
+  CONFLUENCE: "Confluence",
+  GIT: "Git",
+  KUBERNETES: "Kubernetes",
+  AWS: "AWS",
+  GCP: "GCP",
+  KEYCLOAK: "Keycloak",
+  AZURE: "Azure",
+  ELASTIC: "Elastic",
+  OPENAPI: "OpenAPI",
+  PLUGIN: "Plugin",
+  FILESYSTEM: "FileSystem",
+  SCHEDULER: "Scheduler",
+  WEBHOOK: "Webhook",
+  EMAIL: "Email",
+  AZURE_DEVOPS: "AzureDevOps",
+  SONAR: "Sonar",
+  SQL: "SQL",
+  TELEGRAM: "Telegram",
+  ZEPHYR_CLOUD: "ZephyrCloud",
+  ZEPHYR_SQUAD: "ZephyrSquad",
+  SERVICE_NOW: "ServiceNow",
+  DIAL: "DIAL",
+  A2A: "A2A",
+  MCP: "MCP"
+};
+var IntegrationType = {
+  USER: "user",
+  PROJECT: "project"
+};
+
+// src/schemas/integration.ts
+var import_zod2 = require("zod");
+var IntegrationListParamsSchema = import_zod2.z.object({
+  setting_type: import_zod2.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).default(IntegrationType.USER),
+  page: import_zod2.z.number().default(0),
+  per_page: import_zod2.z.number().default(10),
+  filters: import_zod2.z.record(import_zod2.z.unknown()).optional()
+}).readonly();
+var IntegrationGetParamsSchema = import_zod2.z.object({
+  integration_id: import_zod2.z.string(),
+  setting_type: import_zod2.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).default(IntegrationType.USER)
+}).readonly();
+var IntegrationGetByAliasParamsSchema = import_zod2.z.object({
+  alias: import_zod2.z.string(),
+  setting_type: import_zod2.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).default(IntegrationType.USER)
+}).readonly();
+var CredentialValueSchema = import_zod2.z.object({
+  key: import_zod2.z.string(),
+  value: import_zod2.z.unknown()
+});
+var IntegrationCreateParamsSchema = import_zod2.z.object({
+  credential_type: import_zod2.z.enum(Object.values(CredentialTypes)),
+  credential_values: import_zod2.z.array(CredentialValueSchema),
+  project_name: import_zod2.z.string(),
+  setting_type: import_zod2.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).default(IntegrationType.USER),
+  alias: import_zod2.z.string().optional(),
+  default: import_zod2.z.boolean().optional().default(false),
+  project: import_zod2.z.string().optional(),
+  enabled: import_zod2.z.boolean().optional().default(true),
+  external_id: import_zod2.z.string().optional()
+}).readonly();
+var IntegrationUpdateParamsSchema = IntegrationCreateParamsSchema;
+
+// src/services/integration.ts
+var IntegrationService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get base API path based on setting type.
+   */
+  getBasePath(settingType) {
+    return `/v1/settings/${settingType === IntegrationType.USER ? "user" : "project"}`;
+  }
+  /**
+   * Get list of available integrations.
+   */
+  async list(_params = {}) {
+    const params = IntegrationListParamsSchema.parse(_params);
+    const settingType = params.setting_type;
+    const queryParams = {
+      page: params.page,
+      per_page: params.per_page,
+      ...params.filters && { filters: JSON.stringify(params.filters) }
+    };
+    const response = await this.api.get(
+      this.getBasePath(settingType),
+      queryParams
+    );
+    return response.data;
+  }
+  /**
+   * Get integration by ID.
+   */
+  async get(_params) {
+    const params = IntegrationGetParamsSchema.parse(_params);
+    const settingType = params.setting_type;
+    const integrationId = params.integration_id;
+    const integrations = await this.list({
+      per_page: 100,
+      setting_type: settingType
+    });
+    const integration = integrations.find((i) => i.id === integrationId);
+    if (!integration) {
+      throw new NotFoundError("Integration", integrationId);
+    }
+    return integration;
+  }
+  /**
+   * Get integration by alias.
+   */
+  async getByAlias(_params) {
+    const params = IntegrationGetByAliasParamsSchema.parse(_params);
+    const settingType = params.setting_type;
+    const alias = params.alias;
+    const integrations = await this.list({
+      per_page: 100,
+      setting_type: settingType
+    });
+    const integration = integrations.find((i) => i.alias === alias);
+    if (!integration) {
+      throw new NotFoundError("Integration", alias);
+    }
+    return integration;
+  }
+  /**
+   * Create a new integration.
+   */
+  async create(_params) {
+    const params = IntegrationCreateParamsSchema.parse(_params);
+    const settingType = params.setting_type;
+    return this.api.post(this.getBasePath(settingType), {
+      ...params,
+      setting_type: settingType,
+      default: false
+    });
+  }
+  /**
+   * Update an existing integration.
+   */
+  async update(settingId, _params) {
+    const params = IntegrationUpdateParamsSchema.parse(_params);
+    const settingType = params.setting_type;
+    return this.api.put(`${this.getBasePath(settingType)}/${settingId}`, {
+      ...params,
+      setting_type: settingType,
+      default: false
+    });
+  }
+  /**
+   * Delete an integration by ID.
+   */
+  async delete(settingId, settingType = IntegrationType.USER) {
+    return this.api.delete(`${this.getBasePath(settingType)}/${settingId}`);
+  }
+};
+
+// src/services/llm.ts
+var LLMService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get list of available LLM models.
+   */
+  async list() {
+    return this.api.get("/v1/llm_models");
+  }
+  /**
+   * Get list of available embeddings models.
+   */
+  async listEmbeddings() {
+    return this.api.get("/v1/embeddings_models");
+  }
+};
+
+// src/services/task.ts
+var TaskService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get a background task by ID.
+   */
+  async get(taskId) {
+    return this.api.get(`/v1/tasks/${taskId}`);
+  }
+};
+
+// src/mappers/user.mapper.ts
+var UserMapper = class {
+  static mapAboutUserResponse(response) {
+    return omitUndefined({
+      user_id: response.userId,
+      name: response.name,
+      username: response.username,
+      is_admin: response.isAdmin,
+      applications: response.applications,
+      applications_admin: response.applicationsAdmin,
+      picture: response.picture,
+      knowledge_bases: response.knowledgeBases
+    });
+  }
+};
+
+// src/services/user.ts
+var UserService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get current user profile.
+   */
+  async aboutMe() {
+    const response = await this.api.get("/v1/user");
+    return UserMapper.mapAboutUserResponse(response);
+  }
+  /**
+   * Get user data and preferences.
+   */
+  async getData() {
+    return this.api.get("/v1/user/data");
+  }
+};
+
+// src/mappers/workflow.mapper.ts
+var WorkflowMapper = class {
+  static mapWorkflowResponse(response) {
+    return omitUndefined({
+      id: response.id,
+      project: response.project,
+      name: response.name,
+      description: response.description,
+      yaml_config: response.yaml_config,
+      mode: response.mode,
+      shared: response.shared,
+      icon_url: response.icon_url,
+      created_date: response.date,
+      update_date: response.update_date,
+      created_by: response.created_by
+    });
+  }
+  static mapWorkflowExecutionResponse(response) {
+    return omitUndefined({
+      id: response.id,
+      execution_id: response.execution_id,
+      workflow_id: response.workflow_id,
+      overall_status: response.status,
+      created_date: response.date,
+      prompt: response.prompt,
+      updated_date: response.updated_date,
+      created_by: response.created_by,
+      tokens_usage: response.tokens_usage
+    });
+  }
+};
+
+// src/schemas/workflow.ts
+var import_zod3 = require("zod");
+
+// src/models/workflow.ts
+var WorkflowMode = {
+  SEQUENTIAL: "Sequential",
+  AUTONOMOUS: "Autonomous"
+};
+var ExecutionStatus = {
+  IN_PROGRESS: "In Progress",
+  NOT_STARTED: "Not Started",
+  INTERRUPTED: "Interrupted",
+  FAILED: "Failed",
+  SUCCEEDED: "Succeeded",
+  ABORTED: "Aborted"
+};
+
+// src/schemas/workflow.ts
+var WorkflowListParamsSchema = import_zod3.z.object({
+  page: import_zod3.z.number().default(0),
+  per_page: import_zod3.z.number().default(10),
+  projects: import_zod3.z.array(import_zod3.z.string()).optional()
+}).readonly();
+var WorkflowCreateParamsSchema = import_zod3.z.object({
+  project: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string().optional(),
+  yaml_config: import_zod3.z.string(),
+  mode: import_zod3.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]),
+  shared: import_zod3.z.boolean(),
+  icon_url: import_zod3.z.string().optional()
+}).readonly();
+var WorkflowUpdateParamsSchema = import_zod3.z.object({
+  project: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string().optional(),
+  yaml_config: import_zod3.z.string(),
+  mode: import_zod3.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]).optional(),
+  shared: import_zod3.z.boolean().optional(),
+  icon_url: import_zod3.z.string().optional()
+}).readonly();
+var WorkflowExecutionListParamsSchema = import_zod3.z.object({
+  page: import_zod3.z.number().default(0),
+  per_page: import_zod3.z.number().default(10)
+}).readonly();
+var WorkflowExecutionCreateParamsSchema = import_zod3.z.object({
+  user_input: import_zod3.z.string().default("")
+}).readonly();
+var WorkflowExecutionStateListParamsSchema = import_zod3.z.object({
+  page: import_zod3.z.number().default(0),
+  per_page: import_zod3.z.number().default(10)
+}).readonly();
+
+// src/services/workflow_execution_state.ts
+var WorkflowExecutionStateService = class {
+  constructor(api, workflowId, executionId) {
+    this.api = api;
+    this.workflowId = workflowId;
+    this.executionId = executionId;
+  }
+  /**
+   * List states for the workflow execution with filtering and pagination support.
+   */
+  async list(_params = {}) {
+    const params = WorkflowExecutionStateListParamsSchema.parse(_params);
+    const queryParams = {
+      page: params.page,
+      per_page: params.per_page
+    };
+    const response = await this.api.get(
+      `/v1/workflows/${this.workflowId}/executions/${this.executionId}/states`,
+      { params: queryParams }
+    );
+    return response.data;
+  }
+  /**
+   * Get output for a specific execution state.
+   */
+  async getOutput(stateId) {
+    return this.api.get(
+      `/v1/workflows/${this.workflowId}/executions/${this.executionId}/states/${stateId}/output`
+    );
+  }
+};
+
+// src/services/workflow_execution.ts
+var WorkflowExecutionService = class {
+  constructor(api, workflowId) {
+    this.api = api;
+    this.workflowId = workflowId;
+  }
+  /**
+   * List executions for the workflow with filtering and pagination support.
+   */
+  async list(_params = {}) {
+    const params = WorkflowExecutionListParamsSchema.parse(_params);
+    const queryParams = {
+      page: params.page,
+      per_page: params.per_page
+    };
+    const response = await this.api.get(
+      `/v1/workflows/${this.workflowId}/executions`,
+      { params: queryParams }
+    );
+    return response.data.map(WorkflowMapper.mapWorkflowExecutionResponse);
+  }
+  /**
+   * Create a new workflow execution.
+   */
+  async create(userInput = "") {
+    const params = WorkflowExecutionCreateParamsSchema.parse({ user_input: userInput });
+    return this.api.post(`/v1/workflows/${this.workflowId}/executions`, params);
+  }
+  /**
+   * Get workflow execution by ID.
+   */
+  async get(executionId) {
+    const response = await this.api.get(
+      `/v1/workflows/${this.workflowId}/executions/${executionId}`
+    );
+    return WorkflowMapper.mapWorkflowExecutionResponse(response);
+  }
+  /**
+   * Get states service for a specific workflow execution.
+   */
+  states(executionId) {
+    return new WorkflowExecutionStateService(this.api, this.workflowId, executionId);
+  }
+  /**
+   * Delete all workflow executions.
+   */
+  async deleteAll() {
+    return this.api.delete(`/v1/workflows/${this.workflowId}/executions`);
+  }
+  /**
+   * Abort a running workflow execution.
+   */
+  async abort(executionId) {
+    return this.api.put(`/v1/workflows/${this.workflowId}/executions/${executionId}/abort`);
+  }
+  /**
+   * Resume an interrupted workflow execution.
+   */
+  async resume(executionId) {
+    return this.api.put(`/v1/workflows/${this.workflowId}/executions/${executionId}/resume`);
+  }
+};
+
+// src/services/workflow.ts
+var WorkflowService = class {
+  constructor(apiDomain, token, verifySSL = true) {
+    this.api = new ApiRequestHandler(apiDomain, token, verifySSL);
+  }
+  /**
+   * Get list of prebuilt workflows.
+   */
+  async getPrebuilt() {
+    const response = await this.api.get("/v1/workflows/prebuilt");
+    return response.map(WorkflowMapper.mapWorkflowResponse);
+  }
+  /**
+   * Create a new workflow.
+   */
+  async create(_params) {
+    const params = WorkflowCreateParamsSchema.parse(_params);
+    return this.api.post("/v1/workflows", params);
+  }
+  /**
+   * Update an existing workflow.
+   */
+  async update(workflowId, _params) {
+    const params = WorkflowUpdateParamsSchema.parse(_params);
+    return this.api.put(`/v1/workflows/${workflowId}`, params);
+  }
+  /**
+   * List workflows with filtering and pagination support.
+   */
+  async list(_params = {}) {
+    const params = WorkflowListParamsSchema.parse(_params);
+    const queryParams = {
+      filters: JSON.stringify({
+        page: params.page,
+        per_page: params.per_page,
+        ...params.projects?.length ? { projects: params.projects } : {}
+      })
+    };
+    const workflows = await this.api.get("/v1/workflows", {
+      params: queryParams
+    });
+    return workflows.data.map(WorkflowMapper.mapWorkflowResponse);
+  }
+  /**
+   * Get workflow by ID.
+   */
+  async get(workflowId) {
+    const response = await this.api.get(`/v1/workflows/id/${workflowId}`);
+    return WorkflowMapper.mapWorkflowResponse(response);
+  }
+  /**
+   * Delete a workflow by ID.
+   */
+  async delete(workflowId) {
+    return this.api.delete(`/v1/workflows/${workflowId}`);
+  }
+  /**
+   * Run a workflow by ID.
+   */
+  async run(workflowId, userInput = "") {
+    return this.executions(workflowId).create(userInput);
+  }
+  /**
+   * Get workflow execution service for the specified workflow.
+   */
+  executions(workflowId) {
+    return new WorkflowExecutionService(this.api, workflowId);
+  }
+};
+
+// src/client/client.ts
+var CodeMieClient = class {
+  constructor(config) {
+    this.token = null;
+    const {
+      auth_server_url,
+      auth_realm_name,
+      codemie_api_domain,
+      auth_client_id,
+      auth_client_secret,
+      username,
+      password,
+      verify_ssl = true
+    } = config;
+    this.auth = new KeycloakCredentials({
+      serverUrl: auth_server_url,
+      realmName: auth_realm_name,
+      clientId: auth_client_id,
+      clientSecret: auth_client_secret,
+      username,
+      password,
+      verifySSL: verify_ssl
+    });
+    this.apiDomain = codemie_api_domain.replace(/\/$/, "");
+    this.verifySSL = verify_ssl;
+    this.token = "";
+    this._assistants = new AssistantService(this.apiDomain, this.token, this.verifySSL);
+    this._llms = new LLMService(this.apiDomain, this.token, this.verifySSL);
+    this._integrations = new IntegrationService(this.apiDomain, this.token, this.verifySSL);
+    this._tasks = new TaskService(this.apiDomain, this.token, this.verifySSL);
+    this._users = new UserService(this.apiDomain, this.token, this.verifySSL);
+    this._datasources = new DatasourceService(this.apiDomain, this.token, this.verifySSL);
+    this._workflows = new WorkflowService(this.apiDomain, this.token, this.verifySSL);
+  }
+  /**
+   * Get the AssistantService instance.
+   */
+  get assistants() {
+    return this._assistants;
+  }
+  /**
+   * Get the LLMService instance.
+   */
+  get llms() {
+    return this._llms;
+  }
+  /**
+   * Get the IntegrationService instance.
+   */
+  get integrations() {
+    return this._integrations;
+  }
+  /**
+   * Get the TaskService instance.
+   */
+  get tasks() {
+    return this._tasks;
+  }
+  /**
+   * Get the UserService instance.
+   */
+  get users() {
+    return this._users;
+  }
+  /**
+   * Get the DatasourceService instance.
+   */
+  get datasources() {
+    return this._datasources;
+  }
+  /**
+   * Get the WorkflowService instance.
+   */
+  get workflows() {
+    return this._workflows;
+  }
+  /**
+   * Initialize the client by obtaining the initial token.
+   * This should be called after creating the client instance.
+   */
+  async initialize() {
+    this.token = await this.auth.getToken();
+    await this.refreshServices();
+  }
+  /**
+   * Get the current access token or fetch a new one if not available.
+   */
+  async getToken() {
+    if (!this.token) {
+      this.token = await this.auth.getToken();
+      await this.refreshServices();
+    }
+    return this.token;
+  }
+  /**
+   * Force token refresh and update all services with the new token.
+   */
+  async refreshToken() {
+    this.token = await this.auth.getToken();
+    await this.refreshServices();
+    return this.token;
+  }
+  /**
+   * Reinitialize all services with the current token.
+   */
+  async refreshServices() {
+    if (!this.token) {
+      throw new Error("Token not available");
+    }
+    this._assistants = new AssistantService(this.apiDomain, this.token, this.verifySSL);
+    this._llms = new LLMService(this.apiDomain, this.token, this.verifySSL);
+    this._integrations = new IntegrationService(this.apiDomain, this.token, this.verifySSL);
+    this._tasks = new TaskService(this.apiDomain, this.token, this.verifySSL);
+    this._users = new UserService(this.apiDomain, this.token, this.verifySSL);
+    this._datasources = new DatasourceService(this.apiDomain, this.token, this.verifySSL);
+    this._workflows = new WorkflowService(this.apiDomain, this.token, this.verifySSL);
+  }
+};
+
+// src/models/assistant.ts
+var ContextType = /* @__PURE__ */ ((ContextType2) => {
+  ContextType2["KNOWLEDGE_BASE"] = "knowledge_base";
+  ContextType2["CODE"] = "code";
+  return ContextType2;
+})(ContextType || {});
+var ChatRole = /* @__PURE__ */ ((ChatRole2) => {
+  ChatRole2["ASSISTANT"] = "Assistant";
+  ChatRole2["USER"] = "User";
+  return ChatRole2;
+})(ChatRole || {});
+
+// src/models/llm.ts
+var LLMProvider = {
+  AZURE_OPENAI: "azure_openai",
+  AWS_BEDROCK: "aws_bedrock",
+  GOOGLE_VERTEXAI: "google_vertexai"
+};
+
+// src/models/task.ts
+var BackgroundTaskStatus = {
+  STARTED: "STARTED",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AssistantChatParamsSchema,
+  AssistantCreateParamsSchema,
+  AssistantListParamsSchema,
+  AssistantUpdateParamsSchema,
+  BackgroundTaskStatus,
+  ChatRole,
+  CodeDataSourceType,
+  CodeMieClient,
+  CodeMieError,
+  ContextType,
+  CredentialTypes,
+  DataSourceStatus,
+  DataSourceType,
+  ExecutionStatus,
+  IntegrationCreateParamsSchema,
+  IntegrationGetByAliasParamsSchema,
+  IntegrationGetParamsSchema,
+  IntegrationListParamsSchema,
+  IntegrationType,
+  IntegrationUpdateParamsSchema,
+  LLMProvider,
+  NotFoundError,
+  WorkflowCreateParamsSchema,
+  WorkflowExecutionCreateParamsSchema,
+  WorkflowExecutionListParamsSchema,
+  WorkflowExecutionStateListParamsSchema,
+  WorkflowListParamsSchema,
+  WorkflowMode,
+  WorkflowUpdateParamsSchema
+});
+//# sourceMappingURL=index.cjs.map