@caspian2026/agent-sdk 0.0.8 → 0.0.9

package/dist/chunk-1efrnkxx.js

@@ -0,0 +1,468 @@
+// @bun
+import {
+  checkInstall,
+  init_nativeInstaller
+} from "./chunk-w6mcmmt5.js";
+import {
+  getSettingsWithAllErrors,
+  init_allErrors
+} from "./chunk-9wf3fc4t.js";
+import {
+  getDoctorDiagnostic,
+  init_doctorDiagnostic
+} from "./chunk-wa0xgm6m.js";
+import {
+  MAX_MEMORY_CHARACTER_COUNT,
+  SandboxManager,
+  getIdeClientName,
+  getLargeMemoryFiles,
+  getMemoryFiles,
+  init_claudemd,
+  init_ide,
+  init_sandbox_adapter,
+  isJetBrainsIde,
+  toIDEDisplayName
+} from "./chunk-93vwm44t.js";
+import {
+  getAPIProvider,
+  init_model,
+  init_providers,
+  modelDisplayString
+} from "./chunk-7cje7scj.js";
+import {
+  getMTLSConfig,
+  getProxyUrl,
+  init_mtls,
+  init_proxy
+} from "./chunk-7krg0dkt.js";
+import {
+  getAccountInformation,
+  getDisplayPath,
+  getEnabledSettingSources,
+  getManagedFileSettingsPresence,
+  getPolicySettingsOrigin,
+  getSettingSourceDisplayNameCapitalized,
+  getSettingsForSource,
+  init_auth,
+  init_constants,
+  init_file,
+  init_settings1 as init_settings
+} from "./chunk-qctsv1d7.js";
+import {
+  formatNumber,
+  init_format
+} from "./chunk-j35mw64g.js";
+import {
+  ThemedText,
+  color,
+  init_src
+} from "./chunk-c7jwbe76.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-7sgtxrsc.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-qajrkk97.js";
+import {
+  getAWSRegion,
+  getDefaultVertexRegion,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-nsc89h0n.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/status.tsx
+function buildSandboxProperties() {
+  if (process.env.USER_TYPE !== "ant") {
+    return [];
+  }
+  const isSandboxed = SandboxManager.isSandboxingEnabled();
+  return [
+    {
+      label: "Bash Sandbox",
+      value: isSandboxed ? "Enabled" : "Disabled"
+    }
+  ];
+}
+function buildIDEProperties(mcpClients, ideInstallationStatus = null, theme) {
+  const ideClient = mcpClients?.find((client) => client.name === "ide");
+  if (ideInstallationStatus) {
+    const ideName = toIDEDisplayName(ideInstallationStatus.ideType);
+    const pluginOrExtension = isJetBrainsIde(ideInstallationStatus.ideType) ? "plugin" : "extension";
+    if (ideInstallationStatus.error) {
+      return [
+        {
+          label: "IDE",
+          value: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            children: [
+              color("error", theme)(figures_default.cross),
+              " Error installing ",
+              ideName,
+              " ",
+              pluginOrExtension,
+              ": ",
+              ideInstallationStatus.error,
+              `
+`,
+              "Please restart your IDE and try again."
+            ]
+          }, undefined, true, undefined, this)
+        }
+      ];
+    }
+    if (ideInstallationStatus.installed) {
+      if (ideClient && ideClient.type === "connected") {
+        if (ideInstallationStatus.installedVersion !== ideClient.serverInfo?.version) {
+          return [
+            {
+              label: "IDE",
+              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion} (server version: ${ideClient.serverInfo?.version})`
+            }
+          ];
+        } else {
+          return [
+            {
+              label: "IDE",
+              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion}`
+            }
+          ];
+        }
+      } else {
+        return [
+          {
+            label: "IDE",
+            value: `Installed ${ideName} ${pluginOrExtension}`
+          }
+        ];
+      }
+    }
+  } else if (ideClient) {
+    const ideName = getIdeClientName(ideClient) ?? "IDE";
+    if (ideClient.type === "connected") {
+      return [
+        {
+          label: "IDE",
+          value: `Connected to ${ideName} extension`
+        }
+      ];
+    } else {
+      return [
+        {
+          label: "IDE",
+          value: `${color("error", theme)(figures_default.cross)} Not connected to ${ideName}`
+        }
+      ];
+    }
+  }
+  return [];
+}
+function buildMcpProperties(clients = [], theme) {
+  const servers = clients.filter((client) => client.name !== "ide");
+  if (!servers.length) {
+    return [];
+  }
+  const byState = { connected: 0, pending: 0, needsAuth: 0, failed: 0 };
+  for (const s of servers) {
+    if (s.type === "connected")
+      byState.connected++;
+    else if (s.type === "pending")
+      byState.pending++;
+    else if (s.type === "needs-auth")
+      byState.needsAuth++;
+    else
+      byState.failed++;
+  }
+  const parts = [];
+  if (byState.connected)
+    parts.push(color("success", theme)(`${byState.connected} connected`));
+  if (byState.needsAuth)
+    parts.push(color("warning", theme)(`${byState.needsAuth} need auth`));
+  if (byState.pending)
+    parts.push(color("inactive", theme)(`${byState.pending} pending`));
+  if (byState.failed)
+    parts.push(color("error", theme)(`${byState.failed} failed`));
+  return [
+    {
+      label: "MCP servers",
+      value: `${parts.join(", ")} ${color("inactive", theme)("\xB7 /mcp")}`
+    }
+  ];
+}
+async function buildMemoryDiagnostics() {
+  const files = await getMemoryFiles();
+  const largeFiles = getLargeMemoryFiles(files);
+  const diagnostics = [];
+  largeFiles.forEach((file) => {
+    const displayPath = getDisplayPath(file.path);
+    diagnostics.push(`Large ${displayPath} will impact performance (${formatNumber(file.content.length)} chars > ${formatNumber(MAX_MEMORY_CHARACTER_COUNT)})`);
+  });
+  return diagnostics;
+}
+function buildSettingSourcesProperties() {
+  const enabledSources = getEnabledSettingSources();
+  const sourcesWithSettings = enabledSources.filter((source) => {
+    const settings = getSettingsForSource(source);
+    return settings !== null && Object.keys(settings).length > 0;
+  });
+  const sourceNames = sourcesWithSettings.map((source) => {
+    if (source === "policySettings") {
+      const origin = getPolicySettingsOrigin();
+      if (origin === null) {
+        return null;
+      }
+      switch (origin) {
+        case "remote":
+          return "Enterprise managed settings (remote)";
+        case "plist":
+          return "Enterprise managed settings (plist)";
+        case "hklm":
+          return "Enterprise managed settings (HKLM)";
+        case "file": {
+          const { hasBase, hasDropIns } = getManagedFileSettingsPresence();
+          if (hasBase && hasDropIns) {
+            return "Enterprise managed settings (file + drop-ins)";
+          }
+          if (hasDropIns) {
+            return "Enterprise managed settings (drop-ins)";
+          }
+          return "Enterprise managed settings (file)";
+        }
+        case "hkcu":
+          return "Enterprise managed settings (HKCU)";
+      }
+    }
+    return getSettingSourceDisplayNameCapitalized(source);
+  }).filter((name) => name !== null);
+  return [
+    {
+      label: "Setting sources",
+      value: sourceNames
+    }
+  ];
+}
+async function buildInstallationDiagnostics() {
+  const installWarnings = await checkInstall();
+  return installWarnings.map((warning) => warning.message);
+}
+async function buildInstallationHealthDiagnostics() {
+  const diagnostic = await getDoctorDiagnostic();
+  const items = [];
+  const { errors: validationErrors } = getSettingsWithAllErrors();
+  if (validationErrors.length > 0) {
+    const invalidFiles = Array.from(new Set(validationErrors.map((error) => error.file)));
+    const fileList = invalidFiles.join(", ");
+    items.push(`Found invalid settings files: ${fileList}. They will be ignored.`);
+  }
+  diagnostic.warnings.forEach((warning) => {
+    items.push(warning.issue);
+  });
+  if (diagnostic.hasUpdatePermissions === false) {
+    items.push("No write permissions for auto-updates (requires sudo)");
+  }
+  return items;
+}
+function buildAccountProperties() {
+  const accountInfo = getAccountInformation();
+  if (!accountInfo) {
+    return [];
+  }
+  const properties = [];
+  if (accountInfo.subscription) {
+    properties.push({
+      label: "Login method",
+      value: `${accountInfo.subscription} Account`
+    });
+  }
+  if (accountInfo.tokenSource) {
+    properties.push({
+      label: "Auth token",
+      value: accountInfo.tokenSource
+    });
+  }
+  if (accountInfo.apiKeySource) {
+    properties.push({
+      label: "API key",
+      value: accountInfo.apiKeySource
+    });
+  }
+  if (accountInfo.organization && !process.env.IS_DEMO) {
+    properties.push({
+      label: "Organization",
+      value: accountInfo.organization
+    });
+  }
+  if (accountInfo.email && !process.env.IS_DEMO) {
+    properties.push({
+      label: "Email",
+      value: accountInfo.email
+    });
+  }
+  return properties;
+}
+function buildAPIProviderProperties() {
+  const apiProvider = getAPIProvider();
+  const properties = [];
+  if (apiProvider !== "firstParty") {
+    const providerLabel = {
+      bedrock: "AWS Bedrock",
+      vertex: "Google Vertex AI",
+      foundry: "Microsoft Foundry",
+      gemini: "Gemini API",
+      grok: "Grok API",
+      openai: "OpenAI API"
+    }[apiProvider];
+    properties.push({
+      label: "API provider",
+      value: providerLabel
+    });
+  }
+  if (apiProvider === "firstParty") {
+    const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL;
+    if (anthropicBaseUrl) {
+      properties.push({
+        label: "Anthropic base URL",
+        value: anthropicBaseUrl
+      });
+    }
+  } else if (apiProvider === "bedrock") {
+    const bedrockBaseUrl = process.env.BEDROCK_BASE_URL;
+    if (bedrockBaseUrl) {
+      properties.push({
+        label: "Bedrock base URL",
+        value: bedrockBaseUrl
+      });
+    }
+    properties.push({
+      label: "AWS region",
+      value: getAWSRegion()
+    });
+    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {
+      properties.push({
+        value: "AWS auth skipped"
+      });
+    }
+  } else if (apiProvider === "vertex") {
+    const vertexBaseUrl = process.env.VERTEX_BASE_URL;
+    if (vertexBaseUrl) {
+      properties.push({
+        label: "Vertex base URL",
+        value: vertexBaseUrl
+      });
+    }
+    const gcpProject = process.env.ANTHROPIC_VERTEX_PROJECT_ID;
+    if (gcpProject) {
+      properties.push({
+        label: "GCP project",
+        value: gcpProject
+      });
+    }
+    properties.push({
+      label: "Default region",
+      value: getDefaultVertexRegion()
+    });
+    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {
+      properties.push({
+        value: "GCP auth skipped"
+      });
+    }
+  } else if (apiProvider === "foundry") {
+    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL;
+    if (foundryBaseUrl) {
+      properties.push({
+        label: "Microsoft Foundry base URL",
+        value: foundryBaseUrl
+      });
+    }
+    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE;
+    if (foundryResource) {
+      properties.push({
+        label: "Microsoft Foundry resource",
+        value: foundryResource
+      });
+    }
+    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FOUNDRY_AUTH)) {
+      properties.push({
+        value: "Microsoft Foundry auth skipped"
+      });
+    }
+  } else if (apiProvider === "gemini") {
+    const geminiBaseUrl = process.env.GEMINI_BASE_URL || "https://generativelanguage.googleapis.com/v1beta";
+    properties.push({
+      label: "Gemini base URL",
+      value: geminiBaseUrl
+    });
+  } else if (apiProvider === "grok") {
+    const grokBaseUrl = process.env.GROK_BASE_URL;
+    properties.push({
+      label: "Grok base URL",
+      value: grokBaseUrl
+    });
+  } else if (apiProvider === "openai") {
+    const openaiBaseUrl = process.env.OPENAI_BASE_URL;
+    properties.push({
+      label: "OpenAI base URL",
+      value: openaiBaseUrl
+    });
+  }
+  const proxyUrl = getProxyUrl();
+  if (proxyUrl) {
+    properties.push({
+      label: "Proxy",
+      value: proxyUrl
+    });
+  }
+  const mtlsConfig = getMTLSConfig();
+  if (process.env.NODE_EXTRA_CA_CERTS) {
+    properties.push({
+      label: "Additional CA cert(s)",
+      value: process.env.NODE_EXTRA_CA_CERTS
+    });
+  }
+  if (mtlsConfig) {
+    if (mtlsConfig.cert && process.env.CLAUDE_CODE_CLIENT_CERT) {
+      properties.push({
+        label: "mTLS client cert",
+        value: process.env.CLAUDE_CODE_CLIENT_CERT
+      });
+    }
+    if (mtlsConfig.key && process.env.CLAUDE_CODE_CLIENT_KEY) {
+      properties.push({
+        label: "mTLS client key",
+        value: process.env.CLAUDE_CODE_CLIENT_KEY
+      });
+    }
+  }
+  return properties;
+}
+function getModelDisplayLabel(mainLoopModel) {
+  let modelLabel = modelDisplayString(mainLoopModel);
+  return modelLabel;
+}
+var jsx_dev_runtime;
+var init_status = __esm(() => {
+  init_figures();
+  init_src();
+  init_auth();
+  init_claudemd();
+  init_doctorDiagnostic();
+  init_envUtils();
+  init_file();
+  init_format();
+  init_ide();
+  init_model();
+  init_providers();
+  init_mtls();
+  init_nativeInstaller();
+  init_proxy();
+  init_sandbox_adapter();
+  init_allErrors();
+  init_constants();
+  init_settings();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { buildSandboxProperties, buildIDEProperties, buildMcpProperties, buildMemoryDiagnostics, buildSettingSourcesProperties, buildInstallationDiagnostics, buildInstallationHealthDiagnostics, buildAccountProperties, buildAPIProviderProperties, getModelDisplayLabel, init_status };

package/dist/chunk-1gaw18rz.js

@@ -0,0 +1,93 @@
+// @bun
+import {
+  FastModePicker,
+  call,
+  init_fast
+} from "./chunk-ecv9kbtk.js";
+import"./chunk-cnsj3vq2.js";
+import"./chunk-93vwm44t.js";
+import"./chunk-mcws22k3.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-rz94yg8c.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-1gx78081.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-54wn2jdr.js";
+import"./chunk-wkt2q02c.js";
+import"./chunk-87xg6yb4.js";
+import"./chunk-2yxqz99n.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-sdfvr9ps.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-xswyz2es.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-b6prbsae.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-68ffk5qa.js";
+import"./chunk-ratnrv9v.js";
+import"./chunk-7cje7scj.js";
+import"./chunk-7krg0dkt.js";
+import"./chunk-kxrrtr3p.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-6wzg2hpc.js";
+import"./chunk-9w114071.js";
+import"./chunk-3pzwd6qq.js";
+import"./chunk-2vteceqh.js";
+import"./chunk-xeb6075z.js";
+import"./chunk-nrjtxhyr.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-2vbash3m.js";
+import"./chunk-bzatg35k.js";
+import"./chunk-qctsv1d7.js";
+import"./chunk-p4196wzm.js";
+import"./chunk-7hrmxpha.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-rkv8bdtr.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-z6wm96eh.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-1v01c96r.js";
+import"./chunk-8b2y3x7a.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-cexw1jmv.js";
+import"./chunk-j35mw64g.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x8d2ehd7.js";
+import"./chunk-3e28fvn0.js";
+import"./chunk-kjqyhxz7.js";
+import"./chunk-4ayjwyqj.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-40s88wdg.js";
+import"./chunk-5cxjxxx8.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-qcrpqjya.js";
+import"./chunk-skp5w8bq.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-pd2vy8hx.js";
+import"./chunk-nsc89h0n.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import"./chunk-qp2qdcda.js";
+init_fast();
+
+export {
+  call,
+  FastModePicker
+};

package/dist/{chunk-69r3hm9b.js → chunk-1hqb50ne.js}

@@ -10,38 +10,35 @@ import {
   init_xml as init_xml2,
   last_default,
   parsePluginIdentifier
-} from "./chunk-f2hbn5rk.js";
+} from "./chunk-93vwm44t.js";
 import {
   _overRest_default,
   _setToString_default,
-  getClaudeAIOAuthTokens,
   getFeatureValue_CACHED_MAY_BE_STALE,
   getSettingsForSource,
-  getSubscriptionType,
   init__overRest,
   init__setToString,
-  init_auth,
   init_growthbook,
   init_isPlainObject,
   init_settings1 as init_settings,
   isPlainObject_default
-} from "./chunk-e7efcp3k.js";
+} from "./chunk-qctsv1d7.js";
 import {
   init_lazySchema,
   lazySchema
 } from "./chunk-64c1avct.js";
 import {
   init_v4
-} from "./chunk-8g747a8x.js";
+} from "./chunk-4pbx3g7s.js";
 import {
   exports_external
-} from "./chunk-d7886r6a.js";
+} from "./chunk-26wtxbdc.js";
 import {
   CHANNEL_TAG,
   init_log,
   init_xml,
   logError
-} from "./chunk-1nk93fqz.js";
+} from "./chunk-5cxjxxx8.js";
 import {
   _baseClone_default,
   _copyObject_default,
@@ -56,7 +53,7 @@ import {
   jsonParse,
   jsonStringify,
   logForDebugging
-} from "./chunk-phd1qfpc.js";
+} from "./chunk-pd2vy8hx.js";
 import {
   _arrayMap_default,
   _arrayPush_default,
@@ -291,15 +288,13 @@ function gateChannelServer(serverName, capabilities, pluginSource) {
       reason: "channels feature is not currently available"
     };
   }
-  if (!getClaudeAIOAuthTokens()?.accessToken) {
-    return {
-      action: "skip",
-      kind: "auth",
-      reason: "channels requires claude.ai authentication (run /login)"
-    };
-  }
-  const sub = getSubscriptionType();
-  const managed = sub === "team" || sub === "enterprise";
+  return {
+    action: "skip",
+    kind: "auth",
+    reason: "channels requires claude.ai authentication (run /login)"
+  };
+  const sub = null;
+  const managed = false;
   const policy = managed ? getSettingsForSource("policySettings") : undefined;
   if (managed && policy?.channelsEnabled !== true) {
     return {
@@ -351,7 +346,6 @@ var init_channelNotification = __esm(() => {
   init_v4();
   init_state();
   init_xml();
-  init_auth();
   init_lazySchema();
   init_pluginIdentifier();
   init_settings();