@thinkingai/ae-cli 6.0.53 → 6.0.55

package/dist/automation-VAAQBM7Y.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-3YVEAZUN.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-GHXZK54S.js";
+import "./chunk-ZL7SGNIA.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-F2RIR5DS.js → capability-JRIFC4AJ.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-KPQY44JQ.js";
 import {
   resolveHost
-} from "./chunk-N4BLPJC7.js";
+} from "./chunk-OP44TT4H.js";
 import {
   CapabilityGatewayError,
   dryRunCapabilityWithEnvelope,
@@ -20,24 +20,24 @@ import {
   inspectCapabilityWithEnvelope,
   listCapabilitiesWithEnvelope,
   validateCapabilityWithEnvelope
-} from "./chunk-QYXDJOLA.js";
+} from "./chunk-VZZNLV3I.js";
 import {
   printError,
   printOutput,
   withOutputMetadata
-} from "./chunk-BW7JUDEI.js";
+} from "./chunk-6VNIR4AP.js";
 import "./chunk-Y74WTIKJ.js";
 import {
   CredentialStoreUnreadableError,
   SecureStoreAuthError
-} from "./chunk-DU72X2IO.js";
+} from "./chunk-GHXZK54S.js";
 import {
   safeJsonParse
-} from "./chunk-IG3DYEIR.js";
+} from "./chunk-ZL7SGNIA.js";
 import {
   CliValidationError,
   PermissionError
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/commands/capability/index.ts
 import * as readline from "readline";

package/dist/{chunk-647BRKZK.js → chunk-374V5R6N.js}

@@ -6,13 +6,13 @@ import {
   dryRunCapability,
   executeCapabilityWithEnvelope,
   validateCapability
-} from "./chunk-QYXDJOLA.js";
+} from "./chunk-VZZNLV3I.js";
 import {
   withOutputMetadata
-} from "./chunk-BW7JUDEI.js";
+} from "./chunk-6VNIR4AP.js";
 import {
   CliValidationError
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/definition-intent.ts
 import { createHash } from "crypto";

package/dist/{chunk-KJDOTPYU.js → chunk-3YVEAZUN.js}

@@ -4,14 +4,15 @@ import {
 } from "./chunk-Y74WTIKJ.js";
 import {
   getCliToken
-} from "./chunk-DU72X2IO.js";
+} from "./chunk-GHXZK54S.js";
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-IG3DYEIR.js";
+} from "./chunk-ZL7SGNIA.js";
 import {
-  PermissionError
-} from "./chunk-YVGXGTD6.js";
+  PermissionError,
+  isApiErrorType
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
@@ -81,19 +82,27 @@ function readLegacyCredentials() {
   }
 }
 function tryLoadTeAgentSandboxCredentials() {
-  const legacy = readLegacyCredentials();
-  const persistent = readPersistentEnv();
-  const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
-  if (typeof url !== "string" || !url) {
-    return null;
+  const credentials = readSandboxCredentials();
+  return credentials.url ? { ...credentials, url: credentials.url } : null;
+}
+function readSandboxCredentials() {
+  let url = process.env.TE_CLAUDE_BASE_URL || null;
+  let sandboxId = process.env.SANDBOX_ID || null;
+  let sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || null;
+  if (!url || !sandboxId || !sandboxSecretKey) {
+    const persistent = readPersistentEnv();
+    url ||= persistent?.TE_CLAUDE_BASE_URL || null;
+    sandboxId ||= persistent?.SANDBOX_ID || null;
+    sandboxSecretKey ||= persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || null;
   }
-  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId || null;
-  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey || null;
-  return {
-    url,
-    sandboxId: typeof sandboxId === "string" ? sandboxId : null,
-    sandboxSecretKey: typeof sandboxSecretKey === "string" ? sandboxSecretKey : null
-  };
+  if (!url || !sandboxId || !sandboxSecretKey) {
+    const legacy = readLegacyCredentials();
+    url ||= typeof legacy?.url === "string" ? legacy.url : null;
+    sandboxId ||= typeof legacy?.sandboxId === "string" ? legacy.sandboxId : null;
+    const legacySecret = legacy?.sandboxSecretKey || legacy?.secretKey;
+    sandboxSecretKey ||= typeof legacySecret === "string" ? legacySecret : null;
+  }
+  return { url, sandboxId, sandboxSecretKey };
 }
 function getClaudeConfigDir() {
   const fromEnv = process.env.CLAUDE_CONFIG_DIR;
@@ -120,16 +129,22 @@ function resolveTeClaudeBaseUrl(host) {
 
 // src/core/te-agent-client.ts
 var TeAgentApiError = class extends Error {
-  constructor(message, status, code, body) {
+  constructor(message, status, code, body, errorType = "api", hint, details) {
     super(message);
     this.status = status;
     this.code = code;
     this.body = body;
+    this.errorType = errorType;
+    this.hint = hint;
+    this.details = details;
     this.name = "TeAgentApiError";
   }
   status;
   code;
   body;
+  errorType;
+  hint;
+  details;
 };
 var DEFAULT_TIMEOUT_MS = 3e4;
 var UPLOAD_TIMEOUT_MS = 12e4;
@@ -183,7 +198,16 @@ function teClaudeBaseFromActiveHost(hostOverride) {
   return resolveTeClaudeBaseUrl(h);
 }
 async function signRequest(method, path2, hostOverride, includeJsonContentType = true) {
-  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  const configuredHost = hostOverride || getActiveHost();
+  const sandboxOnly = !hostOverride && (/* @__PURE__ */ new Set([
+    "/api/sandbox/models",
+    "/api/sandbox/models/select",
+    "/api/sandbox/sync/push",
+    "/api/sandbox/sync/push/skill",
+    "/api/sandbox/sync/pull",
+    "/api/sandbox/sync/pull/candidates"
+  ])).has(path2.split("?")[0]);
+  const sandboxCred = configuredHost && !sandboxOnly ? null : tryLoadTeAgentSandboxCredentials();
   if (!hostOverride && sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
     const headers = {
       "X-Sandbox-Id": sandboxCred.sandboxId,
@@ -205,7 +229,7 @@ async function signRequest(method, path2, hostOverride, includeJsonContentType =
       "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
     );
   }
-  const hostForToken = hostOverride || getActiveHost() || baseUrl;
+  const hostForToken = configuredHost || baseUrl;
   const contentTypeHeader = includeJsonContentType && (method === "POST" || method === "PATCH" || method === "PUT") ? { "Content-Type": "application/json" } : {};
   const cliToken = await getCliToken(hostForToken);
   return {
@@ -241,7 +265,13 @@ function errorDetails(parsed, defaultErrorPrefix, status) {
   const message = typeof parsed?.error === "string" ? parsed.error : typeof nested?.message === "string" ? nested.message : typeof parsed?.message === "string" ? parsed.message : typeof parsed?.return_message === "string" ? parsed.return_message : `${defaultErrorPrefix} ${status}`;
   const code = typeof nested?.code === "string" ? nested.code : typeof parsed?.code === "string" ? parsed.code : void 0;
   const hint = typeof nested?.hint === "string" ? nested.hint : typeof parsed?.hint === "string" ? parsed.hint : void 0;
-  return { message, code, hint };
+  const declaredType = isApiErrorType(nested?.type) ? nested.type : void 0;
+  const type = status === 401 ? "auth" : status === 403 ? "permission" : declaredType ?? ([400, 413, 422].includes(status) ? "validation" : status === 404 ? "not_found" : "api");
+  return { message, code, hint, type, details: declaredType ? nested?.details : void 0 };
+}
+function createTeAgentApiError(body, status, defaultErrorPrefix = "Main app returned") {
+  const error = errorDetails(body, defaultErrorPrefix, status);
+  return new TeAgentApiError(error.message, status, error.code, body, error.type, error.hint, error.details);
 }
 async function parseResponse(response, defaultErrorPrefix) {
   const text = await response.text();
@@ -256,17 +286,20 @@ async function parseResponse(response, defaultErrorPrefix) {
   if (!response.ok) {
     const details = errorDetails(parsed, defaultErrorPrefix, response.status);
     if (response.status === 403) {
-      throw new PermissionError(details.message, details.code, details.hint);
+      throw new PermissionError(details.message, details.code, details.hint, details.details);
     }
     if (response.status === 401) {
       throw new TeAgentApiError(
-        "Session expired or unauthorized. Please run: ae-cli auth login",
+        isApiErrorType(parsed?.error?.type) && typeof parsed.error.message === "string" && parsed.error.message.trim() ? details.message : "Session expired or unauthorized. Please run: ae-cli auth login",
         response.status,
-        "auth_expired",
-        parsed
+        details.code ?? "auth_expired",
+        parsed,
+        "auth",
+        details.hint ?? "Run: ae-cli auth login",
+        details.details
       );
     }
-    throw new TeAgentApiError(details.message, response.status, details.code, parsed);
+    throw createTeAgentApiError(parsed, response.status, defaultErrorPrefix);
   }
   return parsed;
 }
@@ -483,10 +516,10 @@ async function uploadToMainApp(path2, formData, hostOverride) {
 
 export {
   TeAgentCredentialsError,
-  tryLoadTeAgentSandboxCredentials,
   getClaudeConfigDir,
   resolveTeClaudeBaseUrl,
   TeAgentApiError,
+  createTeAgentApiError,
   postToMainApp,
   getFromMainApp,
   getSandboxModels,