@eng-ai/sdk 2.2.0 → 2.5.0

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 All notable changes to `@eng-ai/sdk` will be documented in this file.
 
+## 2.5.0 - 2026-04-05
+
+### Added
+
+- External profile support (API key owner scope):
+  - `getProfile()`
+  - `updateProfile({ preferredName?, honorific?, crea?, specialty?, avatarUrl? })`
+- CLI `eng-ai` profile commands:
+  - `profile get`
+  - `profile set --preferred-name ... --honorific ... --crea ... --specialty ... --avatar-url ...`
+
+### Changed
+
+- Frontend profile update flow now writes through backend API only (`/api/v1/auth/me/profile`) and no longer depends on direct profile writes in Supabase client.
+
+## 2.4.0 - 2026-04-05
+
+### Added
+
+- External user settings support (API key only):
+  - `getAISettings()`
+  - `setAISettings({ provider, model, projectModel?, apiKey?, googleApiKeyRag?, preferredTimezone? })`
+  - `clearAISettings()`
+  - `setVoiceLiveEnabled(enabled)`
+  - `getGeneralSettings()`
+  - `setGeneralSettings(preferredTimezone?)`
+- CLI `eng-ai` commands for external settings:
+  - `settings ai get|set|clear`
+  - `settings ai voice-live --enabled true|false`
+  - `settings general get|set`
+
+## 2.3.0 - 2026-04-05
+
+### Added
+
+- External project autonomy support:
+  - `setProjectAutonomyMode(projectId, mode, { idempotencyKey? })`
+  - `getProjectContext(projectId)`
+- External automation plan approval flow support:
+  - `listActionableAutomationPlans(limit?)`
+  - `listProjectAutomationPlans(projectId, { status? })`
+  - `approveAutomationPlan(projectId, planId, note?, { idempotencyKey? })`
+  - `rejectAutomationPlan(projectId, planId, note?, { idempotencyKey? })`
+  - `applyAutomationPlan(projectId, planId, { idempotencyKey? })`
+- Official package CLI (`eng-ai`) with commands:
+  - `projects autonomy set`
+  - `plans actionable list`
+  - `plans approve|reject|apply`
+  - `plans watch --interval`
+
 ## 2.2.0 - 2026-04-05
 
 ### Added

package/README.md

@@ -57,8 +57,8 @@ try {
 
 Agent mode options:
 
-- `ENG_AI_AGENT_MODE=autonomous`: omite `agent_id` e deixa o orquestrador escolher.
-- `ENG_AI_AGENT_MODE=specialist`: fixa `agent_id` via `ENG_AI_AGENT_ID` (ex.: `general`, `contract_manager`).
+- `ENG_AI_AGENT_MODE=autonomous`: omite `agent_id` e deixa o Core Orchestrator escolher.
+- `ENG_AI_AGENT_MODE=specialist`: fixa `agent_id` via `ENG_AI_AGENT_ID` (ex.: `general`, `contract_manager` ou alias `project_manager`).
 
 Project creation (API key only):
 
@@ -73,6 +73,76 @@ const projects = await client.listProjects({ limit: 10, offset: 0 });
 console.log(project.id, projects.length);
 ```
 
+Task autonomy mode by project:
+
+```js
+await client.setProjectAutonomyMode(project.id, "approval_required");
+const context = await client.getProjectContext(project.id);
+console.log(context.autonomous_tasks_mode);
+```
+
+External approval flow (pull):
+
+```js
+const actionable = await client.listActionableAutomationPlans(30);
+const pending = actionable.find((plan) => plan.status === "pending_approval");
+if (pending) {
+  await client.approveAutomationPlan(pending.project_id, pending.id, "Approved by integration bot");
+  await client.applyAutomationPlan(pending.project_id, pending.id);
+}
+```
+
+Supported automation plan actions:
+
+- `listActionableAutomationPlans(limit?)`
+- `listProjectAutomationPlans(projectId, { status? })`
+- `approveAutomationPlan(projectId, planId, note?, { idempotencyKey? })`
+- `rejectAutomationPlan(projectId, planId, note?, { idempotencyKey? })`
+- `applyAutomationPlan(projectId, planId, { idempotencyKey? })`
+
+External user settings (API key owner scope):
+
+```js
+const ai = await client.getAISettings();
+await client.setAISettings({
+  provider: "google",
+  model: "gemini-3.1-flash-lite-preview",
+  projectModel: "gemini-3.1-flash-lite-preview",
+  preferredTimezone: "America/Sao_Paulo",
+});
+await client.setVoiceLiveEnabled(true);
+const general = await client.getGeneralSettings();
+await client.setGeneralSettings(general.preferred_timezone || "America/Sao_Paulo");
+```
+
+External profile (API key owner scope):
+
+```js
+const profile = await client.getProfile();
+await client.updateProfile({
+  preferredName: "Felipe",
+  honorific: "Eng.",
+  crea: "123456/D",
+  specialty: "Geotecnia",
+});
+```
+
+CLI (`eng-ai`) included in package:
+
+```bash
+ENG_AI_API_KEY=sk_xxx eng-ai projects autonomy set --project-id <id> --mode approval_required
+ENG_AI_API_KEY=sk_xxx eng-ai plans actionable list --limit 30
+ENG_AI_API_KEY=sk_xxx eng-ai plans approve --project-id <id> --plan-id <id> --note "Approved"
+ENG_AI_API_KEY=sk_xxx eng-ai plans apply --project-id <id> --plan-id <id>
+ENG_AI_API_KEY=sk_xxx eng-ai plans watch --interval 15 --limit 30
+ENG_AI_API_KEY=sk_xxx eng-ai settings ai get
+ENG_AI_API_KEY=sk_xxx eng-ai settings ai set --provider google --model gemini-3.1-flash-lite-preview --preferred-timezone America/Sao_Paulo
+ENG_AI_API_KEY=sk_xxx eng-ai settings ai voice-live --enabled true
+ENG_AI_API_KEY=sk_xxx eng-ai settings general set --preferred-timezone America/Sao_Paulo
+ENG_AI_API_KEY=sk_xxx eng-ai profile get
+ENG_AI_API_KEY=sk_xxx eng-ai profile set --preferred-name Felipe --honorific "Eng." --crea "123456/D" --specialty Geotecnia
+```
+
 Default base URL: `https://api.eng-ai.com/api/v2`.
 
 ## Security Notes

package/bin/eng-ai.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+
+import { EngAIClient, EngAIError } from "../src/client.js";
+
+function parseArgs(argv) {
+  const tokens = [];
+  const options = {};
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = String(argv[i] || "");
+    if (!item.startsWith("--")) {
+      tokens.push(item);
+      continue;
+    }
+
+    const key = item.slice(2);
+    const next = argv[i + 1];
+    if (next !== undefined && !String(next).startsWith("--")) {
+      options[key] = next;
+      i += 1;
+    } else {
+      options[key] = "true";
+    }
+  }
+
+  return { tokens, options };
+}
+
+function envOrDefault(name, fallback = undefined) {
+  const value = process.env[name];
+  if (value === undefined || value === null || String(value).trim() === "") {
+    return fallback;
+  }
+  return String(value).trim();
+}
+
+function toPositiveInt(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+}
+
+function toBoolean(value, fallback = undefined) {
+  if (value === undefined || value === null) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function maskId(value) {
+  const text = String(value || "");
+  if (text.length <= 8) return text;
+  return `${text.slice(0, 4)}...${text.slice(-4)}`;
+}
+
+function printHelp() {
+  console.log(`
+ENG-AI SDK CLI
+
+Usage:
+  eng-ai projects autonomy set --project-id <id> --mode <approval_required|approval_delete_only|full_autonomy> [--idempotency-key <key>]
+  eng-ai plans actionable list [--limit <n>]
+  eng-ai plans approve --project-id <id> --plan-id <id> [--note <text>] [--idempotency-key <key>]
+  eng-ai plans reject --project-id <id> --plan-id <id> [--note <text>] [--idempotency-key <key>]
+  eng-ai plans apply --project-id <id> --plan-id <id> [--idempotency-key <key>]
+  eng-ai plans watch [--interval <seconds>] [--limit <n>]
+  eng-ai settings ai get
+  eng-ai settings ai set --provider <openai|anthropic|google> --model <name> [--project-model <name>] [--api-key <key>] [--google-api-key-rag <key>] [--preferred-timezone <IANA_TZ>]
+  eng-ai settings ai clear
+  eng-ai settings ai voice-live --enabled <true|false>
+  eng-ai settings general get
+  eng-ai settings general set [--preferred-timezone <IANA_TZ>]
+  eng-ai profile get
+  eng-ai profile set [--preferred-name <name>] [--honorific <text>] [--crea <text>] [--specialty <text>] [--avatar-url <url>]
+
+Environment:
+  ENG_AI_API_KEY   (required)
+  ENG_AI_BASE_URL  (optional, default: https://api.eng-ai.com/api/v2)
+`);
+}
+
+function buildClient() {
+  const apiKey = envOrDefault("ENG_AI_API_KEY");
+  if (!apiKey) {
+    throw new Error("ENG_AI_API_KEY is required");
+  }
+  const baseUrl = envOrDefault("ENG_AI_BASE_URL", "https://api.eng-ai.com/api/v2");
+  return new EngAIClient(apiKey, baseUrl);
+}
+
+function printError(error) {
+  if (error instanceof EngAIError) {
+    const payload = {
+      status: error.status,
+      code: error.code,
+      detail: error.detail,
+      requestId: error.requestId,
+      retryAfter: error.retryAfter,
+      idempotencyKey: error.idempotencyKey ? maskId(error.idempotencyKey) : null,
+    };
+    console.error("ENG-AI request failed");
+    console.error(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.error(error?.message || String(error));
+}
+
+async function runProjectsCommand(client, subTokens, options) {
+  if (subTokens[0] !== "autonomy" || subTokens[1] !== "set") {
+    throw new Error("Unsupported projects command. Use: projects autonomy set");
+  }
+
+  const projectId = options["project-id"];
+  const mode = options.mode;
+  const idempotencyKey = options["idempotency-key"];
+  if (!projectId || !mode) {
+    throw new Error("Missing required options: --project-id and --mode");
+  }
+
+  const context = await client.setProjectAutonomyMode(projectId, mode, {
+    idempotencyKey,
+  });
+
+  console.log("Project autonomy mode updated.");
+  console.log(
+    JSON.stringify(
+      {
+        project_id: context.project_id,
+        autonomous_tasks_mode: context.autonomous_tasks_mode,
+        autonomous_tasks_enabled: context.autonomous_tasks_enabled,
+      },
+      null,
+      2
+    )
+  );
+}
+
+function printPlansSummary(plans) {
+  const rows = Array.isArray(plans) ? plans : [];
+  const formatted = rows.map((plan) => ({
+    plan_id: plan.id,
+    project_id: plan.project_id,
+    project_name: plan.project_name || null,
+    status: plan.status,
+    risk_level: plan.risk_level,
+    created_at: plan.created_at,
+  }));
+  console.log(JSON.stringify(formatted, null, 2));
+}
+
+async function runPlansCommand(client, subTokens, options) {
+  const action = subTokens[0];
+
+  if (action === "actionable" && subTokens[1] === "list") {
+    const limit = toPositiveInt(options.limit, 30);
+    const plans = await client.listActionableAutomationPlans(limit);
+    printPlansSummary(plans);
+    return;
+  }
+
+  if (action === "watch") {
+    const intervalSeconds = toPositiveInt(options.interval, 15);
+    const limit = toPositiveInt(options.limit, 30);
+    console.log(
+      `Watching actionable plans every ${intervalSeconds}s (limit=${limit}). Press Ctrl+C to stop.`
+    );
+    while (true) {
+      const plans = await client.listActionableAutomationPlans(limit);
+      const pending = (plans || []).filter((item) => item?.status === "pending_approval");
+      const stamp = new Date().toISOString();
+      console.log(`\n[${stamp}] actionable=${(plans || []).length} pending=${pending.length}`);
+      if (pending.length > 0) {
+        printPlansSummary(pending);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1000));
+    }
+  }
+
+  if (!["approve", "reject", "apply"].includes(action)) {
+    throw new Error("Unsupported plans command. Use actionable list|watch|approve|reject|apply");
+  }
+
+  const projectId = options["project-id"];
+  const planId = options["plan-id"];
+  const note = options.note;
+  const idempotencyKey = options["idempotency-key"];
+  if (!projectId || !planId) {
+    throw new Error("Missing required options: --project-id and --plan-id");
+  }
+
+  let result;
+  if (action === "approve") {
+    result = await client.approveAutomationPlan(projectId, planId, note, {
+      idempotencyKey,
+    });
+  } else if (action === "reject") {
+    result = await client.rejectAutomationPlan(projectId, planId, note, {
+      idempotencyKey,
+    });
+  } else {
+    result = await client.applyAutomationPlan(projectId, planId, {
+      idempotencyKey,
+    });
+  }
+
+  console.log(`Plan ${action} completed.`);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function runSettingsCommand(client, subTokens, options) {
+  const section = String(subTokens[0] || "").trim().toLowerCase();
+  const action = String(subTokens[1] || "").trim().toLowerCase();
+
+  if (!section || !action) {
+    throw new Error("Unsupported settings command. Use: settings ai|get ...");
+  }
+
+  if (section === "ai") {
+    if (action === "get") {
+      const result = await client.getAISettings();
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (action === "clear") {
+      const result = await client.clearAISettings();
+      console.log("AI settings removed.");
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (action === "set") {
+      const provider = options.provider;
+      const model = options.model;
+      if (!provider || !model) {
+        throw new Error("Missing required options: --provider and --model");
+      }
+
+      const result = await client.setAISettings({
+        provider,
+        model,
+        projectModel: options["project-model"],
+        apiKey: options["api-key"],
+        googleApiKeyRag: options["google-api-key-rag"],
+        preferredTimezone: options["preferred-timezone"],
+      });
+      console.log("AI settings updated.");
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (action === "voice-live") {
+      const enabled = toBoolean(options.enabled, undefined);
+      if (enabled === undefined) {
+        throw new Error("Missing or invalid --enabled. Use --enabled true|false");
+      }
+      const result = await client.setVoiceLiveEnabled(enabled);
+      console.log("Voice-live toggle updated.");
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+  }
+
+  if (section === "general") {
+    if (action === "get") {
+      const result = await client.getGeneralSettings();
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (action === "set") {
+      const result = await client.setGeneralSettings(options["preferred-timezone"] || null);
+      console.log("General settings updated.");
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+  }
+
+  throw new Error("Unsupported settings command. Use ai|get/set/clear/voice-live or general|get/set");
+}
+
+async function runProfileCommand(client, subTokens, options) {
+  const action = String(subTokens[0] || "").trim().toLowerCase();
+  if (action === "get") {
+    const result = await client.getProfile();
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (action === "set") {
+    const payload = {
+      preferredName: options["preferred-name"],
+      honorific: options.honorific,
+      crea: options.crea,
+      specialty: options.specialty,
+      avatarUrl: options["avatar-url"],
+    };
+    const hasAnyField = Object.values(payload).some((value) => value !== undefined);
+    if (!hasAnyField) {
+      throw new Error(
+        "Missing profile fields. Use at least one: --preferred-name, --honorific, --crea, --specialty, --avatar-url"
+      );
+    }
+    const result = await client.updateProfile(payload);
+    console.log("Profile updated.");
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  throw new Error("Unsupported profile command. Use: profile get|set");
+}
+
+async function main() {
+  const { tokens, options } = parseArgs(process.argv.slice(2));
+  const command = tokens[0];
+  if (!command || command === "help" || command === "--help") {
+    printHelp();
+    return;
+  }
+
+  const client = buildClient();
+  if (command === "projects") {
+    await runProjectsCommand(client, tokens.slice(1), options);
+    return;
+  }
+  if (command === "plans") {
+    await runPlansCommand(client, tokens.slice(1), options);
+    return;
+  }
+  if (command === "settings") {
+    await runSettingsCommand(client, tokens.slice(1), options);
+    return;
+  }
+  if (command === "profile") {
+    await runProfileCommand(client, tokens.slice(1), options);
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+main().catch((error) => {
+  printError(error);
+  process.exit(1);
+});

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@eng-ai/sdk",
-  "version": "2.2.0",
+  "version": "2.5.0",
   "description": "Official JavaScript SDK for ENG-AI External API v2",
   "type": "module",
   "main": "./src/client.js",
+  "bin": {
+    "eng-ai": "./bin/eng-ai.js"
+  },
   "exports": {
     ".": "./src/client.js"
   },
   "files": [
+    "bin",
     "src",
     "README.md",
     "CHANGELOG.md",

package/src/client.js

@@ -1,6 +1,11 @@
 const DEFAULT_BASE_URL = "https://api.eng-ai.com/api/v2";
 const DEFAULT_TIMEOUT_MS = 60000;
 const REDACT_KEY_PATTERN = /api[-_]?key|authorization|token|secret|password|cookie|set-cookie/i;
+const VALID_AUTONOMOUS_TASKS_MODES = new Set([
+  "approval_required",
+  "approval_delete_only",
+  "full_autonomy",
+]);
 
 function isPlainObject(value) {
   return !!value && Object.prototype.toString.call(value) === "[object Object]";
@@ -277,6 +282,18 @@ export class EngAIClient {
     }
   }
 
+  _requireNonEmptyString(value, fieldName) {
+    const normalized = String(value || "").trim();
+    if (!normalized) {
+      throw new EngAIError(`${fieldName} is required`, {
+        status: 400,
+        code: "validation_error",
+        detail: `${fieldName} must be a non-empty string`,
+      });
+    }
+    return normalized;
+  }
+
   async invokeAgent(agentIdOrPayload, maybePayload) {
     const implicitAutonomous = arguments.length === 1;
     const agentId = implicitAutonomous ? null : agentIdOrPayload;
@@ -360,4 +377,201 @@ export class EngAIClient {
       method: "GET",
     });
   }
+
+  async getAISettings() {
+    return await this._request("/settings/llm", {
+      method: "GET",
+    });
+  }
+
+  async setAISettings(payload) {
+    const provider = this._requireNonEmptyString(payload?.provider, "provider").toLowerCase();
+    const model = this._requireNonEmptyString(payload?.model, "model");
+    const body = {
+      provider,
+      model,
+      project_model: payload?.projectModel ?? payload?.project_model,
+      api_key: payload?.apiKey ?? payload?.api_key,
+      google_api_key_rag: payload?.googleApiKeyRag ?? payload?.google_api_key_rag,
+      preferred_timezone: payload?.preferredTimezone ?? payload?.preferred_timezone,
+    };
+
+    return await this._request("/settings/llm", {
+      method: "PUT",
+      body,
+    });
+  }
+
+  async clearAISettings() {
+    return await this._request("/settings/llm", {
+      method: "DELETE",
+    });
+  }
+
+  async setVoiceLiveEnabled(enabled) {
+    return await this._request("/settings/voice-live", {
+      method: "PUT",
+      body: { enabled: !!enabled },
+    });
+  }
+
+  async getGeneralSettings() {
+    return await this._request("/settings/general", {
+      method: "GET",
+    });
+  }
+
+  async setGeneralSettings(preferredTimezone = null) {
+    return await this._request("/settings/general", {
+      method: "PUT",
+      body: {
+        preferred_timezone: preferredTimezone || null,
+      },
+    });
+  }
+
+  async getProfile() {
+    return await this._request("/profile", {
+      method: "GET",
+    });
+  }
+
+  async updateProfile(payload = {}) {
+    const body = {
+      preferred_name: payload?.preferredName ?? payload?.preferred_name,
+      honorific: payload?.honorific,
+      crea: payload?.crea ?? payload?.crea_cau,
+      specialty: payload?.specialty,
+      avatar_url: payload?.avatarUrl ?? payload?.avatar_url,
+    };
+
+    const hasAnyField = Object.values(body).some((value) => value !== undefined);
+    if (!hasAnyField) {
+      throw new EngAIError("at least one profile field is required for updateProfile", {
+        status: 400,
+        code: "validation_error",
+        detail:
+          "provide one of: preferred_name, honorific, crea, specialty, avatar_url",
+      });
+    }
+
+    return await this._request("/profile", {
+      method: "PUT",
+      body,
+    });
+  }
+
+  async getProjectContext(projectId) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    return await this._request(`/projects/${encodeURIComponent(normalizedProjectId)}/context`, {
+      method: "GET",
+    });
+  }
+
+  async setProjectAutonomyMode(projectId, mode, options = {}) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    const normalizedMode = String(mode || "").trim().toLowerCase();
+    if (!VALID_AUTONOMOUS_TASKS_MODES.has(normalizedMode)) {
+      throw new EngAIError("invalid mode for setProjectAutonomyMode", {
+        status: 400,
+        code: "validation_error",
+        detail:
+          "mode must be one of: approval_required, approval_delete_only, full_autonomy",
+      });
+    }
+
+    const headers = {};
+    const idempotencyKey = options?.idempotencyKey ?? options?.idempotency_key;
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+
+    return await this._request(
+      `/projects/${encodeURIComponent(normalizedProjectId)}/autonomous-tasks-mode`,
+      {
+        method: "PUT",
+        headers,
+        body: { mode: normalizedMode },
+      }
+    );
+  }
+
+  async listActionableAutomationPlans(limit = 30) {
+    const query = new URLSearchParams();
+    if (limit !== undefined && limit !== null) {
+      query.set("limit", String(limit));
+    }
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return await this._request(`/projects/automation-plans/actionable${suffix}`, {
+      method: "GET",
+    });
+  }
+
+  async listProjectAutomationPlans(projectId, options = {}) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    const query = new URLSearchParams();
+    if (options.status) {
+      query.set("status", String(options.status));
+    }
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return await this._request(
+      `/projects/${encodeURIComponent(normalizedProjectId)}/automation-plans${suffix}`,
+      {
+        method: "GET",
+      }
+    );
+  }
+
+  async approveAutomationPlan(projectId, planId, note = undefined, options = {}) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    const normalizedPlanId = this._requireNonEmptyString(planId, "planId");
+    const headers = {};
+    const idempotencyKey = options?.idempotencyKey ?? options?.idempotency_key;
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    return await this._request(
+      `/projects/${encodeURIComponent(normalizedProjectId)}/automation-plans/${encodeURIComponent(normalizedPlanId)}/approve`,
+      {
+        method: "POST",
+        headers,
+        body: { note: note ?? undefined },
+      }
+    );
+  }
+
+  async rejectAutomationPlan(projectId, planId, note = undefined, options = {}) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    const normalizedPlanId = this._requireNonEmptyString(planId, "planId");
+    const headers = {};
+    const idempotencyKey = options?.idempotencyKey ?? options?.idempotency_key;
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    return await this._request(
+      `/projects/${encodeURIComponent(normalizedProjectId)}/automation-plans/${encodeURIComponent(normalizedPlanId)}/reject`,
+      {
+        method: "POST",
+        headers,
+        body: { note: note ?? undefined },
+      }
+    );
+  }
+
+  async applyAutomationPlan(projectId, planId, options = {}) {
+    const normalizedProjectId = this._requireNonEmptyString(projectId, "projectId");
+    const normalizedPlanId = this._requireNonEmptyString(planId, "planId");
+    const headers = {};
+    const idempotencyKey = options?.idempotencyKey ?? options?.idempotency_key;
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    return await this._request(
+      `/projects/${encodeURIComponent(normalizedProjectId)}/automation-plans/${encodeURIComponent(normalizedPlanId)}/apply`,
+      {
+        method: "POST",
+        headers,
+      }
+    );
+  }
 }