@thinkingai/ae-cli 6.1.24 → 6.1.26

package/dist/automation-NWWVLWG2.js

@@ -0,0 +1,459 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  TeAgentApiError,
+  deleteFromMainApp,
+  getFromMainApp,
+  patchToMainApp,
+  postToMainApp
+} from "./chunk-PLE722AJ.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-GIK6EDUG.js";
+import "./chunk-UQ77JXYH.js";
+import "./chunk-WNGFSIOB.js";
+
+// src/commands/automation/index.ts
+import { randomUUID } from "crypto";
+var base = "/api/cli/automation/v1";
+var flag = (name, desc, type = "string", required = false) => ({ name, desc, type, required });
+var idFlag = flag("id", "Automation ID from list or create", "string", true);
+var typeFlag = flag(
+  "target-type",
+  "agent | team; identifies the existing target on update",
+  "string",
+  true
+);
+var scopeFlag = flag(
+  "agent-space-id",
+  "Explicit space; otherwise server resolves sandbox context or personal space"
+);
+var runFlag = flag(
+  "run-id",
+  "Execution ID from run or runs list",
+  "string",
+  true
+);
+var pageFlags = [
+  flag("limit", "Page size, 1-100 (default 20)", "number"),
+  flag("cursor", "Opaque nextCursor from the previous page")
+];
+var waitFlags = [
+  flag("wait", "Wait for this execution to finish", "boolean"),
+  flag("timeout", "Wait timeout in seconds, 1-86400 (default 300)", "number")
+];
+var requestFlag = flag(
+  "command-id",
+  "Stable idempotency key; reuse it after an uncertain response"
+);
+var configFlags = [
+  typeFlag,
+  flag("name", "Automation name"),
+  {
+    ...flag("message", "Task instructions; an empty string clears it"),
+    sensitive: true
+  },
+  flag("clear-message", "Clear task instructions explicitly", "boolean"),
+  flag("trigger-type", "scheduled | manual"),
+  flag("status", "active | paused"),
+  flag(
+    "cron-expression",
+    "Five-field hourly, daily, weekly or monthly schedule"
+  ),
+  flag("schedule-kind", "hourly | daily | weekly | monthly"),
+  flag("time", "HH:mm in server timezone"),
+  flag("minute", "Hourly minute, 0-59", "number"),
+  flag("weekday", "Weekly day, 0=Sunday through 6=Saturday", "number"),
+  flag("day-of-month", "Monthly day, 1-28", "number"),
+  flag("model", "Agent model configuration ID; null clears the override"),
+  flag("reuse-conversation", "Agent: true | false", "json"),
+  {
+    ...flag("scope", "Team data scope JSON; null clears it", "json"),
+    sensitive: true
+  },
+  flag(
+    "channels",
+    "Team notification channel array; [] clears channels",
+    "json"
+  ),
+  flag("feishu-chat-id", "Team Feishu destination; null clears it"),
+  flag("lark-chat-id", "Team Lark destination; null clears it"),
+  flag("slack-channel-id", "Team Slack destination; null clears it"),
+  flag(
+    "save-to-knowledge-base-id",
+    "Team output knowledge base ID; null clears it"
+  )
+];
+function enumValue(value, values, name) {
+  if (value && !values.includes(value))
+    throw new Error(`--${name} must be ${values.join(" | ")}`);
+}
+function range(value, min, max, name) {
+  if (!Number.isInteger(value) || value < min || value > max)
+    throw new Error(`--${name} must be an integer from ${min} to ${max}`);
+  return value;
+}
+function key(ctx, name) {
+  const value = ctx.str(name);
+  if (!value || value.length > 191)
+    throw new Error(`${name} must be a non-empty ID of at most 191 characters`);
+  return encodeURIComponent(value);
+}
+function configuration(ctx, create) {
+  const targetType = ctx.str("targetType");
+  enumValue(targetType, ["agent", "team"], "target-type");
+  if (!targetType) throw new Error("--target-type is required");
+  const result = {};
+  if (create) {
+    result.targetType = targetType;
+    result[targetType === "agent" ? "agentId" : "teamId"] = decodeURIComponent(
+      key(ctx, targetType === "agent" ? "agentId" : "teamId")
+    );
+  }
+  for (const name2 of ["name", "message", "triggerType", "status"]) {
+    if (ctx.str(name2)) result[name2] = ctx.str(name2);
+  }
+  if (ctx.bool("clearMessage")) {
+    if (ctx.str("message")) throw new Error("Use --message or --clear-message");
+    result.message = "";
+  }
+  if (create && ctx.str(targetType === "agent" ? "teamId" : "agentId"))
+    throw new Error("Specify only the selected target ID");
+  if (create && !ctx.str("name").trim()) throw new Error("--name is required");
+  const name = ctx.str("name");
+  if (name && !name.trim()) throw new Error("--name must not be blank");
+  if (targetType === "team") {
+    if (name.length > 191 || Array.from(name.replace(/\s/g, "")).length > 50)
+      throw new Error(
+        "--name must contain at most 50 non-whitespace characters (191 raw code units)"
+      );
+  } else if (name.trim().length > 100) {
+    throw new Error("--name must contain at most 100 characters");
+  }
+  enumValue(ctx.str("triggerType"), ["scheduled", "manual"], "trigger-type");
+  enumValue(ctx.str("status"), ["active", "paused"], "status");
+  const kind = ctx.str("scheduleKind"), cron = ctx.str("cronExpression");
+  enumValue(kind, ["hourly", "daily", "weekly", "monthly"], "schedule-kind");
+  if (kind && cron) throw new Error("Use --schedule-kind or --cron-expression");
+  if (!kind && ["time", "minute", "weekday", "dayOfMonth"].some((name2) => ctx.str(name2)))
+    throw new Error("Schedule details require --schedule-kind");
+  if (kind && ctx.str("weekday") && kind !== "weekly" || kind && ctx.str("dayOfMonth") && kind !== "monthly" || kind && ctx.str("minute") && kind !== "hourly")
+    throw new Error("Schedule field is not applicable to this frequency");
+  if (kind) {
+    const schedule = { kind };
+    if (kind === "hourly")
+      schedule.minute = range(ctx.optionalNum("minute") ?? 0, 0, 59, "minute");
+    else {
+      if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(ctx.str("time")))
+        throw new Error("--time must use HH:mm");
+      schedule.time = ctx.str("time");
+      if (kind === "weekly")
+        schedule.weekday = range(
+          ctx.optionalNum("weekday") ?? NaN,
+          0,
+          6,
+          "weekday"
+        );
+      if (kind === "monthly")
+        schedule.dayOfMonth = range(
+          ctx.optionalNum("dayOfMonth") ?? NaN,
+          1,
+          28,
+          "day-of-month"
+        );
+    }
+    result.schedule = schedule;
+  }
+  if (cron) {
+    const parts = cron.trim().split(/\s+/);
+    const validNumber = (v, a, b) => /^\d+$/.test(v) && Number(v) >= a && Number(v) <= b;
+    const [m, h, d, mo, w] = parts;
+    if (parts.length !== 5 || !validNumber(m, 0, 59) || !(h === "*" || validNumber(h, 0, 23)) || mo !== "*" || !(d === "*" || validNumber(d, 1, 28)) || !(w === "*" || validNumber(w, 0, 6)) || d !== "*" && w !== "*" || h === "*" && (d !== "*" || w !== "*"))
+      throw new Error(
+        "--cron-expression must specify an hourly, daily, weekly or monthly schedule"
+      );
+    result.cronExpression = cron;
+  }
+  if (create && (ctx.str("triggerType") || "scheduled") === "scheduled" && !kind && !cron)
+    throw new Error("Scheduled automation requires a schedule");
+  const agentNames = ["model", "reuseConversation"];
+  const teamNames = [
+    "scope",
+    "channels",
+    "feishuChatId",
+    "larkChatId",
+    "slackChannelId",
+    "saveToKnowledgeBaseId"
+  ];
+  for (const name2 of [...agentNames, ...teamNames]) {
+    const json = ["scope", "channels", "reuseConversation"].includes(name2);
+    const value = json ? ctx.json(name2) : ctx.str(name2) || void 0;
+    if (value === void 0) continue;
+    if ((agentNames.includes(name2) ? "agent" : "team") !== targetType)
+      throw new Error(`${name2} is not applicable to ${targetType} automations`);
+    if (name2 === "reuseConversation" && typeof value !== "boolean")
+      throw new Error("--reuse-conversation must be true or false");
+    if (name2 === "channels" && (!Array.isArray(value) || value.some(
+      (v) => ![
+        "feishu",
+        "lark",
+        "slack",
+        "discord",
+        "dingtalk",
+        "wecom",
+        "mattermost",
+        "google_chat",
+        "zoom_chat",
+        "whatsapp"
+      ].includes(v)
+    )))
+      throw new Error(
+        "--channels must contain supported notification channels"
+      );
+    if (name2 === "scope" && value !== null && (typeof value !== "object" || Array.isArray(value)))
+      throw new Error("--scope must be an object or null");
+    result[name2 === "scope" ? "scopeJson" : name2] = name2 === "scope" ? value === null ? null : JSON.stringify(value) : value === "null" ? null : value;
+  }
+  if (!create && !Object.keys(result).length)
+    throw new Error("No fields to update");
+  if (create) result.triggerImmediately = ctx.bool("triggerImmediately");
+  return result;
+}
+function query(ctx, list = false, typed = false) {
+  const p = new URLSearchParams();
+  if (ctx.str("agentSpaceId")) p.set("agentSpaceId", ctx.str("agentSpaceId"));
+  if (typed && ctx.str("targetType"))
+    p.set("targetType", ctx.str("targetType"));
+  if (list) {
+    for (const k of ["limit", "cursor", "status", "q", "targetType"])
+      if (ctx.str(k)) p.set(k, ctx.str(k));
+  }
+  return p.size ? `?${p}` : "";
+}
+async function request(ctx, method, path, body) {
+  if (method === "GET")
+    return getFromMainApp(
+      path,
+      ctx.hostOverride ? ctx.hostOverride() : ctx.host()
+    );
+  if (method === "POST")
+    return postToMainApp(
+      path,
+      body,
+      ctx.hostOverride ? ctx.hostOverride() : ctx.host()
+    );
+  if (method === "PATCH")
+    return patchToMainApp(
+      path,
+      body,
+      ctx.hostOverride ? ctx.hostOverride() : ctx.host()
+    );
+  return deleteFromMainApp(
+    path,
+    ctx.hostOverride ? ctx.hostOverride() : ctx.host()
+  );
+}
+function withDryRun(path) {
+  return `${path}${path.includes("?") ? "&" : "?"}dryRun=true`;
+}
+function redactedPreview(method, path, body) {
+  return {
+    method,
+    url: path,
+    ...body === void 0 ? {} : { body: { payload: "[REDACTED]" } }
+  };
+}
+async function waitForRun(ctx, id, runId) {
+  const deadline = Date.now() + (ctx.optionalNum("timeout") ?? 300) * 1e3;
+  do {
+    const result = await request(
+      ctx,
+      "GET",
+      `${base}/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/result${query(ctx)}`
+    );
+    if (result.status !== "running")
+      return { ...result, executionCompleted: true, timedOut: false };
+    if (Date.now() >= deadline)
+      return { ...result, executionCompleted: false, timedOut: true };
+    await new Promise(
+      (resolve) => setTimeout(resolve, Math.min(1e3, deadline - Date.now()))
+    );
+  } while (true);
+}
+var actions = [
+  {
+    command: "list",
+    method: "GET",
+    suffix: () => "",
+    flags: [
+      ...pageFlags,
+      flag("target-type", "Filter agent | team"),
+      flag("status", "Filter active | paused"),
+      flag("q", "Search automation name")
+    ],
+    list: true
+  },
+  {
+    command: "get",
+    method: "GET",
+    suffix: (c) => `/${key(c, "id")}`,
+    flags: [idFlag]
+  },
+  {
+    command: "create",
+    method: "POST",
+    suffix: () => "",
+    flags: [
+      ...configFlags,
+      flag("agent-id", "Agent target ID"),
+      flag("team-id", "Team target ID"),
+      flag(
+        "trigger-immediately",
+        "Execute once after successful creation",
+        "boolean"
+      ),
+      requestFlag,
+      ...waitFlags
+    ],
+    body: (c) => configuration(c, true),
+    wait: true
+  },
+  {
+    command: "update",
+    method: "PATCH",
+    suffix: (c) => `/${key(c, "id")}`,
+    flags: [idFlag, ...configFlags],
+    body: (c) => configuration(c, false),
+    typed: true
+  },
+  ...["enable", "disable"].map((command) => ({
+    command,
+    method: "PATCH",
+    suffix: (c) => `/${key(c, "id")}`,
+    flags: [idFlag],
+    body: () => ({ status: command === "enable" ? "active" : "paused" })
+  })),
+  {
+    command: "delete",
+    method: "DELETE",
+    suffix: (c) => `/${key(c, "id")}`,
+    flags: [idFlag],
+    highRisk: true
+  },
+  {
+    command: "run",
+    method: "POST",
+    suffix: (c) => `/${key(c, "id")}/run`,
+    flags: [idFlag, requestFlag, ...waitFlags],
+    body: () => ({}),
+    wait: true
+  },
+  {
+    command: "list",
+    resource: "runs",
+    method: "GET",
+    suffix: (c) => `/${key(c, "id")}/runs`,
+    flags: [idFlag, ...pageFlags],
+    list: true
+  },
+  ...["get", "result", "stop", "retry"].map((command) => ({
+    command,
+    resource: "runs",
+    method: ["stop", "retry"].includes(command) ? "POST" : "GET",
+    suffix: (c) => `/${key(c, "id")}/runs/${key(c, "runId")}${command === "get" ? "" : `/${command}`}`,
+    flags: [
+      idFlag,
+      runFlag,
+      ...command === "retry" ? [requestFlag, ...waitFlags] : []
+    ],
+    body: ["stop", "retry"].includes(command) ? () => ({}) : void 0,
+    highRisk: command === "stop",
+    wait: command === "retry"
+  }))
+];
+var automationCommands = actions.map((a) => ({
+  service: "automation",
+  resource: a.resource,
+  command: a.command,
+  description: `${a.command} ${a.resource ? "an automation execution" : "Agent or team automations"} (Transitional TE REST)`,
+  risk: a.highRisk ? "high-risk-write" : a.method === "GET" ? "read" : "write",
+  flags: [scopeFlag, ...a.flags ?? []],
+  validate: (ctx) => {
+    a.suffix(ctx);
+    a.body?.(ctx);
+    if (ctx.str("commandId").length > 191)
+      throw new Error("--command-id must contain at most 191 characters");
+    if (ctx.optionalNum("limit") !== void 0)
+      range(ctx.num("limit"), 1, 100, "limit");
+    if (ctx.optionalNum("timeout") !== void 0)
+      range(ctx.num("timeout"), 1, 86400, "timeout");
+    enumValue(ctx.str("targetType"), ["agent", "team"], "target-type");
+    enumValue(ctx.str("status"), ["active", "paused"], "status");
+    if (a.command === "create" && ctx.bool("wait") && !ctx.bool("triggerImmediately"))
+      throw new Error("--wait on create requires --trigger-immediately");
+  },
+  dryRun: async (ctx) => {
+    const body = a.body?.(ctx);
+    const commandId = ctx.str("commandId") || randomUUID();
+    const requestBody = body && {
+      ...body,
+      ...a.wait ? { commandId } : {}
+    };
+    const path = base + a.suffix(ctx) + query(ctx, a.list, a.typed);
+    return {
+      request: redactedPreview(a.method, path, requestBody),
+      validation: await request(ctx, a.method, withDryRun(path), requestBody)
+    };
+  },
+  execute: async (ctx) => {
+    const body = a.body?.(ctx), commandId = ctx.str("commandId") || randomUUID();
+    let output;
+    try {
+      output = await request(
+        ctx,
+        a.method,
+        base + a.suffix(ctx) + query(ctx, a.list, a.typed),
+        body && { ...body, ...a.wait ? { commandId } : {} }
+      );
+    } catch (error) {
+      if (a.wait && a.command !== "create" && error instanceof TeAgentApiError)
+        throw new TeAgentApiError(
+          error.message,
+          error.status,
+          error.code,
+          error.body,
+          error.errorType,
+          [
+            error.hint,
+            `Keep command ID ${commandId}. Reuse it when checking or retrying this execution request.`
+          ].filter(Boolean).join(" "),
+          error.details
+        );
+      throw error;
+    }
+    if (!a.wait) return output;
+    const runId = a.command === "create" ? output.execution?.runId : output.runId;
+    const id = a.command === "create" ? output.automation.id : ctx.str("id");
+    const accepted = { ...output, commandId };
+    if (!ctx.bool("wait") || !runId) return accepted;
+    try {
+      return { ...accepted, result: await waitForRun(ctx, id, runId) };
+    } catch (error) {
+      return {
+        ...accepted,
+        observation: {
+          status: "failed",
+          code: error instanceof TeAgentApiError ? error.code : "OBSERVATION_FAILED",
+          message: "Execution was accepted, but result polling failed. Read the existing run; do not create or trigger again.",
+          automationId: id,
+          runId
+        }
+      };
+    }
+  }
+}));
+var automation_default = automationCommands;
+export {
+  automationCommands,
+  configuration,
+  automation_default as default,
+  waitForRun
+};

package/dist/{capability-FYTU3X6L.js → capability-3QLLIVFB.js}

@@ -11,7 +11,7 @@ import {
   inspectCapabilityWithEnvelope,
   listCapabilitiesWithEnvelope,
   validateCapabilityWithEnvelope
-} from "./chunk-HFGZGYCG.js";
+} from "./chunk-EOYSKMXN.js";
 import {
   findGatewayDomain,
   listCapabilityDiscoveryPrefixes,
@@ -20,23 +20,24 @@ import {
 } from "./chunk-KPQY44JQ.js";
 import {
   resolveHost
-} from "./chunk-JOCDD4ON.js";
+} from "./chunk-7QXISROD.js";
 import {
   printError,
   printOutput,
   withOutputMetadata
-} from "./chunk-DX5CDO34.js";
+} from "./chunk-KFNMQTZI.js";
 import "./chunk-Y74WTIKJ.js";
 import {
+  CredentialStoreUnreadableError,
   SecureStoreAuthError
-} from "./chunk-7XGFSUOM.js";
+} from "./chunk-GIK6EDUG.js";
 import {
   safeJsonParse
-} from "./chunk-7FTTULED.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   CliValidationError,
   PermissionError
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/commands/capability/index.ts
 import * as readline from "readline";
@@ -367,6 +368,10 @@ function printCapabilityError(error, host) {
     );
     return;
   }
+  if (error instanceof CredentialStoreUnreadableError) {
+    printError("config", error.message, error.hint, error.code);
+    return;
+  }
   if (error instanceof SecureStoreAuthError) {
     printError("auth", error.message, "Run: ae-cli auth login");
     return;

package/dist/chunk-4655PUNX.js

@@ -0,0 +1,43 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  deleteFromMainApp,
+  getBufferFromMainApp,
+  getFromMainApp,
+  patchToMainApp,
+  postToMainApp,
+  putToMainApp,
+  uploadToMainApp
+} from "./chunk-PLE722AJ.js";
+
+// src/commands/te-agent/api-client.ts
+function getAgentApi(ctx, path) {
+  return getFromMainApp(path, ctx.host());
+}
+function postAgentApi(ctx, path, body) {
+  return postToMainApp(path, body, ctx.host());
+}
+function patchAgentApi(ctx, path, body) {
+  return patchToMainApp(path, body, ctx.host());
+}
+function putAgentApi(ctx, path, body) {
+  return putToMainApp(path, body, ctx.host());
+}
+function deleteAgentApi(ctx, path) {
+  return deleteFromMainApp(path, ctx.host());
+}
+function uploadAgentApi(ctx, path, formData) {
+  return uploadToMainApp(path, formData, ctx.host());
+}
+function getAgentBuffer(ctx, path) {
+  return getBufferFromMainApp(path, ctx.host());
+}
+
+export {
+  getAgentApi,
+  postAgentApi,
+  patchAgentApi,
+  putAgentApi,
+  deleteAgentApi,
+  uploadAgentApi,
+  getAgentBuffer
+};

package/dist/{chunk-4NRCTUZJ.js → chunk-5XJYLEVC.js}

@@ -1,20 +1,20 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   require_lib
-} from "./chunk-DVMLWQD4.js";
+} from "./chunk-CT7QDJS6.js";
 import {
   require_archiver,
   require_string_decoder
-} from "./chunk-EQ255HKO.js";
+} from "./chunk-AP7YP2NX.js";
 import {
   require_inherits,
   require_node
-} from "./chunk-V2NUHPXF.js";
+} from "./chunk-S6M42KND.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // node_modules/exceljs/lib/utils/under-dash.js
 var require_under_dash = __commonJS({

package/dist/{chunk-JOCDD4ON.js → chunk-7QXISROD.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   getActiveHost,
   normalizeUrl
-} from "./chunk-7FTTULED.js";
+} from "./chunk-UQ77JXYH.js";
 
 // src/core/auth.ts
 function resolveHost(hostOverride) {

package/dist/{chunk-EQ255HKO.js → chunk-AP7YP2NX.js}

@@ -5,14 +5,14 @@ import {
   require_node,
   require_process_nextick_args,
   require_util
-} from "./chunk-V2NUHPXF.js";
+} from "./chunk-S6M42KND.js";
 import {
   __commonJS,
   __esm,
   __export,
   __require,
   __toCommonJS
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // node_modules/readdir-glob/node_modules/minimatch/lib/path.js
 var require_path = __commonJS({

package/dist/{chunk-DVMLWQD4.js → chunk-CT7QDJS6.js}

@@ -5,11 +5,11 @@ import {
   require_node,
   require_process_nextick_args,
   require_util
-} from "./chunk-V2NUHPXF.js";
+} from "./chunk-S6M42KND.js";
 import {
   __commonJS,
   __require
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // node_modules/jszip/node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream = __commonJS({

package/dist/chunk-D6ACFILC.js

@@ -0,0 +1,56 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  getAgentApi,
+  patchAgentApi,
+  postAgentApi
+} from "./chunk-4655PUNX.js";
+
+// src/commands/memory/cli-client.ts
+var DEFAULT_TE_CLAUDE_BASE_PATH = "/agent";
+var MEMORY_CLI_BASE_PATH = "/api/cli/memory/v2";
+function normalizeBasePath(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") return "";
+  return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+function resolveMemoryApiBaseUrl(host) {
+  const base = host.replace(/\/+$/, "");
+  const basePath = normalizeBasePath(
+    process.env.TE_CLAUDE_BASE_PATH ?? process.env.AE_API_PREFIX ?? DEFAULT_TE_CLAUDE_BASE_PATH
+  );
+  return basePath && !base.endsWith(basePath) ? `${base}${basePath}` : base;
+}
+function buildMemoryCliUrl(ctx, path) {
+  return `${resolveMemoryApiBaseUrl(ctx.host())}${MEMORY_CLI_BASE_PATH}/${path.replace(/^\/+/, "")}`;
+}
+function unwrapMemoryResponse(response) {
+  if (response && typeof response === "object" && !Array.isArray(response)) {
+    const envelope = response;
+    if (envelope.ok === true) return envelope.data;
+    if (envelope.ok === false) throw new Error(envelope.error?.message || "Memory API request failed");
+  }
+  return response;
+}
+async function getMemoryCli(ctx, path) {
+  return unwrapMemoryResponse(
+    await getAgentApi(ctx, `${MEMORY_CLI_BASE_PATH}/${path.replace(/^\/+/, "")}`)
+  );
+}
+async function postMemoryCli(ctx, path, body) {
+  return unwrapMemoryResponse(
+    await postAgentApi(ctx, `${MEMORY_CLI_BASE_PATH}/${path.replace(/^\/+/, "")}`, body)
+  );
+}
+async function patchMemoryCli(ctx, path, body) {
+  return unwrapMemoryResponse(
+    await patchAgentApi(ctx, `${MEMORY_CLI_BASE_PATH}/${path.replace(/^\/+/, "")}`, body)
+  );
+}
+
+export {
+  resolveMemoryApiBaseUrl,
+  buildMemoryCliUrl,
+  getMemoryCli,
+  postMemoryCli,
+  patchMemoryCli
+};