@letta-ai/letta-code 0.28.12 → 0.28.13

package/letta.js

@@ -4853,7 +4853,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.28.12",
+    version: "0.28.13",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -441753,6 +441753,115 @@ var init_PasteAwareTextInput = __esm(async () => {
   OPTION_RIGHT_PATTERN = /^\u001b\[(?:1;)?(?:3|4|7|8|9)C$/;
 });
 
+// src/agent/favorites.ts
+function generateFavoriteTag(ownerId) {
+  return `${LETTA_CHAT_FAVORITE_TAG_PREFIX}${ownerId}`;
+}
+async function fetchCurrentUserMetadata() {
+  if (currentUserMetadataFetcherOverride) {
+    return currentUserMetadataFetcherOverride();
+  }
+  return apiRequest("GET", "/v1/metadata/user");
+}
+async function getCurrentCloudFavoriteTag() {
+  try {
+    const user = await fetchCurrentUserMetadata();
+    return typeof user.id === "string" && user.id ? generateFavoriteTag(user.id) : null;
+  } catch {
+    return null;
+  }
+}
+async function getFavoriteTagForAgent(agentId) {
+  if (isLocalAgentId(agentId)) {
+    return LOCAL_DESKTOP_FAVORITE_TAG;
+  }
+  return getCurrentCloudFavoriteTag();
+}
+function getAgentTags(agent2) {
+  return Array.isArray(agent2.tags) ? agent2.tags : [];
+}
+function addFavoriteTag(tags, favoriteTag) {
+  if (tags.includes(favoriteTag))
+    return tags;
+  return [favoriteTag, ...tags];
+}
+function removeFavoriteTag(tags, favoriteTag) {
+  return tags.filter((tag) => tag !== favoriteTag && tag !== LETTA_CHAT_FAVORITE_TAG_BASE);
+}
+function arraysEqual2(a2, b3) {
+  return a2.length === b3.length && a2.every((value, index) => value === b3[index]);
+}
+async function setAgentFavoriteTag(backend4, agentId) {
+  const favoriteTag = await getFavoriteTagForAgent(agentId);
+  if (!favoriteTag)
+    return "unavailable";
+  const agent2 = await backend4.retrieveAgent(agentId, {
+    include: ["agent.tags"]
+  });
+  const tags = getAgentTags(agent2);
+  const nextTags = addFavoriteTag(tags, favoriteTag);
+  if (arraysEqual2(tags, nextTags))
+    return "unchanged";
+  await backend4.updateAgent(agentId, { tags: nextTags });
+  return "changed";
+}
+async function unsetAgentFavoriteTag(backend4, agentId) {
+  const favoriteTag = await getFavoriteTagForAgent(agentId);
+  if (!favoriteTag)
+    return "unavailable";
+  const agent2 = await backend4.retrieveAgent(agentId, {
+    include: ["agent.tags"]
+  });
+  const tags = getAgentTags(agent2);
+  const nextTags = removeFavoriteTag(tags, favoriteTag);
+  if (arraysEqual2(tags, nextTags))
+    return "unchanged";
+  await backend4.updateAgent(agentId, { tags: nextTags });
+  return "changed";
+}
+async function pinAgentForCurrentUser(agentId, backend4 = getBackend()) {
+  const wasPinnedInSettings = settingsManager.isAgentPinned(agentId);
+  try {
+    const result = await setAgentFavoriteTag(backend4, agentId);
+    if (result !== "unavailable") {
+      if (wasPinnedInSettings) {
+        settingsManager.unpinAgent(agentId);
+      }
+      return result === "unchanged" || wasPinnedInSettings ? "already-pinned" : "pinned";
+    }
+  } catch {}
+  if (wasPinnedInSettings)
+    return "already-pinned";
+  settingsManager.pinAgent(agentId);
+  return "pinned";
+}
+async function unpinAgentForCurrentUser(agentId, backend4 = getBackend()) {
+  const wasPinnedInSettings = settingsManager.isAgentPinned(agentId);
+  try {
+    const result = await unsetAgentFavoriteTag(backend4, agentId);
+    if (result !== "unavailable") {
+      if (wasPinnedInSettings) {
+        settingsManager.unpinAgent(agentId);
+      }
+      return result === "changed" || wasPinnedInSettings ? "unpinned" : "not-pinned";
+    }
+  } catch (error54) {
+    if (!wasPinnedInSettings)
+      throw error54;
+  }
+  if (!wasPinnedInSettings)
+    return "not-pinned";
+  settingsManager.unpinAgent(agentId);
+  return "unpinned";
+}
+var LETTA_CHAT_FAVORITE_TAG_BASE = "view:letta-chat", LETTA_CHAT_FAVORITE_TAG_PREFIX = "favorite:user:", LOCAL_FAVORITE_OWNER_ID = "local", LOCAL_DESKTOP_FAVORITE_TAG, currentUserMetadataFetcherOverride = null;
+var init_favorites = __esm(() => {
+  init_backend2();
+  init_request();
+  init_settings_manager();
+  LOCAL_DESKTOP_FAVORITE_TAG = generateFavoriteTag(LOCAL_FAVORITE_OWNER_ID);
+});
+
 // src/backend/local/index.ts
 var init_local = __esm(() => {
   init_context_window_overflow();
@@ -441796,6 +441905,78 @@ var init_local_agent_listing = __esm(() => {
   init_paths();
 });
 
+// src/cli/helpers/pinned-agent-listing.ts
+function hasCloudCredentials2() {
+  if (process.env.LETTA_API_KEY)
+    return true;
+  const settings3 = settingsManager.getSettings();
+  const cached3 = settingsManager.getCachedSecureTokens();
+  return Boolean(cached3.apiKey || cached3.refreshToken || settings3.refreshToken || settings3.env?.LETTA_API_KEY);
+}
+async function listCloudFavoriteAgents2() {
+  if (!hasCloudCredentials2())
+    return [];
+  try {
+    const favoriteTag = await getCurrentCloudFavoriteTag();
+    if (!favoriteTag)
+      return [];
+    const page = await getBackendForMode("api").listAgents({
+      limit: PINNED_AGENT_LIMIT2,
+      include: ["agent.blocks"],
+      order: "desc",
+      order_by: "last_run_completion",
+      tags: [favoriteTag]
+    });
+    return Array.isArray(page) ? page : page.items ?? [];
+  } catch {
+    return [];
+  }
+}
+async function retrieveLegacyPin2(agentId, backendMode) {
+  if (backendMode === "api" && !hasCloudCredentials2()) {
+    return { agentId, agent: null, error: "Not signed in", backendMode };
+  }
+  try {
+    const agent2 = await getBackendForMode(backendMode).retrieveAgent(agentId, {
+      include: ["agent.blocks"]
+    });
+    return { agentId, agent: agent2, error: null, backendMode };
+  } catch {
+    return { agentId, agent: null, error: "Agent not found", backendMode };
+  }
+}
+async function listPinnedAgentsForCurrentUser2(backendModes = ["api", "local"]) {
+  const modes = new Set(backendModes);
+  const legacyPins = [...modes].flatMap((backendMode) => settingsManager.getPinnedAgentsForBackendMode(backendMode).map((agentId) => ({ agentId, backendMode })));
+  const seen = new Set(legacyPins.map(({ agentId, backendMode }) => `${backendMode}:${agentId}`));
+  const legacyData = await Promise.all(legacyPins.map(({ agentId, backendMode }) => retrieveLegacyPin2(agentId, backendMode)));
+  const favoriteAgents = [];
+  if (modes.has("local")) {
+    favoriteAgents.push(...listLocalAgentsFromDisk().filter((agent2) => getAgentTags(agent2).includes(LOCAL_DESKTOP_FAVORITE_TAG)).map((agent2) => ({ agent: agent2, backendMode: "local" })));
+  }
+  if (modes.has("api")) {
+    favoriteAgents.push(...(await listCloudFavoriteAgents2()).map((agent2) => ({
+      agent: agent2,
+      backendMode: "api"
+    })));
+  }
+  const favoriteData = favoriteAgents.flatMap(({ agent: agent2, backendMode }) => {
+    const key2 = `${backendMode}:${agent2.id}`;
+    if (seen.has(key2))
+      return [];
+    seen.add(key2);
+    return [{ agentId: agent2.id, agent: agent2, error: null, backendMode }];
+  });
+  return [...legacyData, ...favoriteData];
+}
+var PINNED_AGENT_LIMIT2 = 100;
+var init_pinned_agent_listing = __esm(() => {
+  init_favorites();
+  init_backend();
+  init_settings_manager();
+  init_local_agent_listing();
+});
+
 // src/cli/components/ModelReasoningSelector.tsx
 function formatEffortLabel(effort, hasDistinctMaxTier) {
   if (effort === "none")
@@ -473059,115 +473240,6 @@ var init_setup_ui = __esm(async () => {
   jsx_dev_runtime14 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
-// src/agent/favorites.ts
-function generateFavoriteTag(ownerId) {
-  return `${LETTA_CHAT_FAVORITE_TAG_PREFIX}${ownerId}`;
-}
-async function fetchCurrentUserMetadata() {
-  if (currentUserMetadataFetcherOverride) {
-    return currentUserMetadataFetcherOverride();
-  }
-  return apiRequest("GET", "/v1/metadata/user");
-}
-async function getCurrentCloudFavoriteTag() {
-  try {
-    const user = await fetchCurrentUserMetadata();
-    return typeof user.id === "string" && user.id ? generateFavoriteTag(user.id) : null;
-  } catch {
-    return null;
-  }
-}
-async function getFavoriteTagForAgent(agentId) {
-  if (isLocalAgentId(agentId)) {
-    return LOCAL_DESKTOP_FAVORITE_TAG;
-  }
-  return getCurrentCloudFavoriteTag();
-}
-function getAgentTags(agent2) {
-  return Array.isArray(agent2.tags) ? agent2.tags : [];
-}
-function addFavoriteTag(tags, favoriteTag) {
-  if (tags.includes(favoriteTag))
-    return tags;
-  return [favoriteTag, ...tags];
-}
-function removeFavoriteTag(tags, favoriteTag) {
-  return tags.filter((tag) => tag !== favoriteTag && tag !== LETTA_CHAT_FAVORITE_TAG_BASE);
-}
-function arraysEqual2(a2, b3) {
-  return a2.length === b3.length && a2.every((value, index) => value === b3[index]);
-}
-async function setAgentFavoriteTag(backend4, agentId) {
-  const favoriteTag = await getFavoriteTagForAgent(agentId);
-  if (!favoriteTag)
-    return "unavailable";
-  const agent2 = await backend4.retrieveAgent(agentId, {
-    include: ["agent.tags"]
-  });
-  const tags = getAgentTags(agent2);
-  const nextTags = addFavoriteTag(tags, favoriteTag);
-  if (arraysEqual2(tags, nextTags))
-    return "unchanged";
-  await backend4.updateAgent(agentId, { tags: nextTags });
-  return "changed";
-}
-async function unsetAgentFavoriteTag(backend4, agentId) {
-  const favoriteTag = await getFavoriteTagForAgent(agentId);
-  if (!favoriteTag)
-    return "unavailable";
-  const agent2 = await backend4.retrieveAgent(agentId, {
-    include: ["agent.tags"]
-  });
-  const tags = getAgentTags(agent2);
-  const nextTags = removeFavoriteTag(tags, favoriteTag);
-  if (arraysEqual2(tags, nextTags))
-    return "unchanged";
-  await backend4.updateAgent(agentId, { tags: nextTags });
-  return "changed";
-}
-async function pinAgentForCurrentUser(agentId, backend4 = getBackend()) {
-  const wasPinnedInSettings = settingsManager.isAgentPinned(agentId);
-  try {
-    const result = await setAgentFavoriteTag(backend4, agentId);
-    if (result !== "unavailable") {
-      if (wasPinnedInSettings) {
-        settingsManager.unpinAgent(agentId);
-      }
-      return result === "unchanged" || wasPinnedInSettings ? "already-pinned" : "pinned";
-    }
-  } catch {}
-  if (wasPinnedInSettings)
-    return "already-pinned";
-  settingsManager.pinAgent(agentId);
-  return "pinned";
-}
-async function unpinAgentForCurrentUser(agentId, backend4 = getBackend()) {
-  const wasPinnedInSettings = settingsManager.isAgentPinned(agentId);
-  try {
-    const result = await unsetAgentFavoriteTag(backend4, agentId);
-    if (result !== "unavailable") {
-      if (wasPinnedInSettings) {
-        settingsManager.unpinAgent(agentId);
-      }
-      return result === "changed" || wasPinnedInSettings ? "unpinned" : "not-pinned";
-    }
-  } catch (error54) {
-    if (!wasPinnedInSettings)
-      throw error54;
-  }
-  if (!wasPinnedInSettings)
-    return "not-pinned";
-  settingsManager.unpinAgent(agentId);
-  return "unpinned";
-}
-var LETTA_CHAT_FAVORITE_TAG_BASE = "view:letta-chat", LETTA_CHAT_FAVORITE_TAG_PREFIX = "favorite:user:", LOCAL_FAVORITE_OWNER_ID = "local", LOCAL_DESKTOP_FAVORITE_TAG, currentUserMetadataFetcherOverride = null;
-var init_favorites = __esm(() => {
-  init_backend2();
-  init_request();
-  init_settings_manager();
-  LOCAL_DESKTOP_FAVORITE_TAG = generateFavoriteTag(LOCAL_FAVORITE_OWNER_ID);
-});
-
 // src/cli/components/OverlayShell.tsx
 function OverlayShell({
   command,
@@ -473457,20 +473529,8 @@ var init_TabBar = __esm(async () => {
 // src/cli/components/AgentSelector.tsx
 var exports_AgentSelector = {};
 __export(exports_AgentSelector, {
-  getPinnedAgentBackendMode: () => getPinnedAgentBackendMode,
   AgentSelector: () => AgentSelector
 });
-function getPinnedAgentBackendMode(agentId) {
-  return isLocalAgentId(agentId) ? "local" : "api";
-}
-function hasCloudCredentials() {
-  const apiKey = process.env.LETTA_API_KEY;
-  if (apiKey)
-    return true;
-  const settings3 = settingsManager.getSettings();
-  const cached3 = settingsManager.getCachedSecureTokens();
-  return Boolean(cached3.apiKey || cached3.refreshToken || settings3.refreshToken || settings3.env?.LETTA_API_KEY);
-}
 function formatRelativeTime3(dateStr) {
   if (!dateStr)
     return "Never";
@@ -473576,77 +473636,7 @@ function AgentSelector({
   const loadPinnedAgents = import_react38.useCallback(async () => {
     setPinnedLoading(true);
     try {
-      const pinnedIds = settingsManager.getPinnedAgents();
-      const pinnedIdSet = new Set(pinnedIds);
-      const localFavoriteAgents = listLocalAgentsFromDisk().filter((agent2) => agent2.tags.includes(LOCAL_DESKTOP_FAVORITE_TAG));
-      let cloudFavoriteAgents = [];
-      if (hasCloudCredentials()) {
-        try {
-          const favoriteTag = await getCurrentCloudFavoriteTag();
-          if (favoriteTag) {
-            const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
-            const client = await getClient2();
-            const agentList = await client.agents.list({
-              limit: FETCH_PAGE_SIZE2,
-              include: ["agent.blocks"],
-              order: "desc",
-              order_by: "last_run_completion",
-              tags: [favoriteTag]
-            });
-            cloudFavoriteAgents = agentList.items;
-          }
-        } catch {}
-      }
-      let pinnedData = [];
-      if (pinnedIds.length > 0) {
-        pinnedData = await Promise.all(pinnedIds.map(async (agentId) => {
-          const backendMode = getPinnedAgentBackendMode(agentId);
-          try {
-            if (backendMode === "api" && !hasCloudCredentials()) {
-              return {
-                agentId,
-                agent: null,
-                error: "Not signed in",
-                backendMode
-              };
-            }
-            const agentBackend = getBackendForMode(backendMode);
-            const agent2 = await agentBackend.retrieveAgent(agentId, {
-              include: ["agent.blocks"]
-            });
-            return {
-              agentId,
-              agent: agent2,
-              error: null,
-              backendMode
-            };
-          } catch {
-            return {
-              agentId,
-              agent: null,
-              error: "Agent not found",
-              backendMode
-            };
-          }
-        }));
-      }
-      const favoriteAgents = [
-        ...localFavoriteAgents.map((agent2) => ({
-          agent: agent2,
-          backendMode: "local"
-        })),
-        ...cloudFavoriteAgents.map((agent2) => ({
-          agent: agent2,
-          backendMode: "api"
-        }))
-      ];
-      const favoriteData = favoriteAgents.filter(({ agent: agent2 }) => !pinnedIdSet.has(agent2.id)).map((agent2) => ({
-        agentId: agent2.agent.id,
-        agent: agent2.agent,
-        error: null,
-        backendMode: agent2.backendMode
-      }));
-      pinnedData = [...pinnedData, ...favoriteData];
+      const pinnedData = await listPinnedAgentsForCurrentUser2();
       const validPinnedData = pinnedData.filter((p2) => p2.agent !== null);
       if (validPinnedData.length === 0) {
         setPinnedAgents([]);
@@ -473728,7 +473718,7 @@ function AgentSelector({
     activeQuery
   ]);
   import_react38.useEffect(() => {
-    setHasCloudAuth(hasCloudCredentials());
+    setHasCloudAuth(hasCloudCredentials2());
   }, []);
   import_react38.useEffect(() => {
     loadPinnedAgents();
@@ -474458,9 +474448,9 @@ var init_AgentSelector = __esm(async () => {
   init_model();
   init_backend();
   init_local_agent_listing();
+  init_pinned_agent_listing();
   init_use_terminal_width();
   init_constants2();
-  init_settings_manager();
   init_colors();
   await __promiseAll([
     init_build4(),
@@ -537640,7 +537630,7 @@ function buildStartupCommandHints(options3) {
     isPinned,
     isLocalBackend,
     hasMessages,
-    hasCloudCredentials: hasCloudCredentials2,
+    hasCloudCredentials: hasCloudCredentials3,
     hasAvailableLocalModels
   } = options3;
   const baseHints = isResumingConversation ? [
@@ -537669,7 +537659,7 @@ function buildStartupCommandHints(options3) {
   if (!hasMessages) {
     onboardingHints.push("→ **/rename**    name your agent", "→ **/init**      initialize your agent's memory");
   }
-  if (!hasCloudCredentials2) {
+  if (!hasCloudCredentials3) {
     onboardingHints.push("→ **/login**     sign in to Constellation");
   }
   const dedupedHints = [];
@@ -541602,24 +541592,22 @@ function resolveStartupTarget(input) {
   if (input.forceNew) {
     return { action: "create", trigger: "force-new" };
   }
-  if (input.pinnedAgentId && input.pinnedAgentExists) {
-    const conversationId = input.pinnedAgentId === input.localAgentId ? input.localConversationId ?? undefined : undefined;
+  if (input.localAgentId && input.localAgentExists) {
     return {
       action: "resume",
-      agentId: input.pinnedAgentId,
-      ...conversationId ? { conversationId } : {}
+      agentId: input.localAgentId,
+      conversationId: input.localConversationId ?? undefined
     };
   }
-  if (input.existingPinnedCount > 1) {
-    return { action: "select" };
-  }
-  if (input.localAgentId && input.localAgentExists) {
+  if (input.pinnedAgentId && input.pinnedAgentExists) {
     return {
       action: "resume",
-      agentId: input.localAgentId,
-      conversationId: input.localConversationId ?? undefined
+      agentId: input.pinnedAgentId
     };
   }
+  if (input.existingPinnedCount > 1) {
+    return { action: "select" };
+  }
   if (input.globalAgentId && input.globalAgentExists) {
     return {
       action: "resume",
@@ -546400,6 +546388,76 @@ async function ensureFdPath() {
   return pendingFdPath;
 }
 
+// src/cli/helpers/pinned-agent-listing.ts
+init_favorites();
+init_backend();
+init_settings_manager();
+init_local_agent_listing();
+var PINNED_AGENT_LIMIT = 100;
+function hasCloudCredentials() {
+  if (process.env.LETTA_API_KEY)
+    return true;
+  const settings3 = settingsManager.getSettings();
+  const cached3 = settingsManager.getCachedSecureTokens();
+  return Boolean(cached3.apiKey || cached3.refreshToken || settings3.refreshToken || settings3.env?.LETTA_API_KEY);
+}
+async function listCloudFavoriteAgents() {
+  if (!hasCloudCredentials())
+    return [];
+  try {
+    const favoriteTag = await getCurrentCloudFavoriteTag();
+    if (!favoriteTag)
+      return [];
+    const page = await getBackendForMode("api").listAgents({
+      limit: PINNED_AGENT_LIMIT,
+      include: ["agent.blocks"],
+      order: "desc",
+      order_by: "last_run_completion",
+      tags: [favoriteTag]
+    });
+    return Array.isArray(page) ? page : page.items ?? [];
+  } catch {
+    return [];
+  }
+}
+async function retrieveLegacyPin(agentId, backendMode) {
+  if (backendMode === "api" && !hasCloudCredentials()) {
+    return { agentId, agent: null, error: "Not signed in", backendMode };
+  }
+  try {
+    const agent2 = await getBackendForMode(backendMode).retrieveAgent(agentId, {
+      include: ["agent.blocks"]
+    });
+    return { agentId, agent: agent2, error: null, backendMode };
+  } catch {
+    return { agentId, agent: null, error: "Agent not found", backendMode };
+  }
+}
+async function listPinnedAgentsForCurrentUser(backendModes = ["api", "local"]) {
+  const modes = new Set(backendModes);
+  const legacyPins = [...modes].flatMap((backendMode) => settingsManager.getPinnedAgentsForBackendMode(backendMode).map((agentId) => ({ agentId, backendMode })));
+  const seen = new Set(legacyPins.map(({ agentId, backendMode }) => `${backendMode}:${agentId}`));
+  const legacyData = await Promise.all(legacyPins.map(({ agentId, backendMode }) => retrieveLegacyPin(agentId, backendMode)));
+  const favoriteAgents = [];
+  if (modes.has("local")) {
+    favoriteAgents.push(...listLocalAgentsFromDisk().filter((agent2) => getAgentTags(agent2).includes(LOCAL_DESKTOP_FAVORITE_TAG)).map((agent2) => ({ agent: agent2, backendMode: "local" })));
+  }
+  if (modes.has("api")) {
+    favoriteAgents.push(...(await listCloudFavoriteAgents()).map((agent2) => ({
+      agent: agent2,
+      backendMode: "api"
+    })));
+  }
+  const favoriteData = favoriteAgents.flatMap(({ agent: agent2, backendMode }) => {
+    const key2 = `${backendMode}:${agent2.id}`;
+    if (seen.has(key2))
+      return [];
+    seen.add(key2);
+    return [{ agentId: agent2.id, agent: agent2, error: null, backendMode }];
+  });
+  return [...legacyData, ...favoriteData];
+}
+
 // src/cli/helpers/terminal-theme.ts
 var TERMINAL_THEME_STATE_KEY2 = Symbol.for("letta.terminalThemeState");
 function getTerminalThemeState2() {
@@ -546502,6 +546560,7 @@ async function initTerminalTheme() {
 // src/cli/profile-selection.tsx
 init_model();
 init_backend2();
+init_pinned_agent_listing();
 await init_build4();
 var import_react30 = __toESM(require_react(), 1);
 
@@ -546603,32 +546662,6 @@ function getLabel(option2, _freshRepoMode) {
     parts.push("pinned");
   return parts.length > 0 ? ` (${parts.join(", ")})` : "";
 }
-function buildInitialProfileOptions(lruAgentId) {
-  const pinned = settingsManager.getPinnedAgents();
-  const options3 = [];
-  const seenAgentIds = new Set;
-  if (lruAgentId) {
-    options3.push({
-      name: null,
-      agentId: lruAgentId,
-      isLru: true,
-      agent: null
-    });
-    seenAgentIds.add(lruAgentId);
-  }
-  for (const agentId of pinned) {
-    if (seenAgentIds.has(agentId))
-      continue;
-    options3.push({
-      name: null,
-      agentId,
-      isLru: false,
-      agent: null
-    });
-    seenAgentIds.add(agentId);
-  }
-  return options3;
-}
 function ProfileSelectionUI({
   lruAgentId,
   externalLoading,
@@ -546639,8 +546672,9 @@ function ProfileSelectionUI({
   serverBaseUrl,
   onComplete
 }) {
-  const [options3, setOptions] = import_react30.useState(() => externalLoading ? [] : buildInitialProfileOptions(lruAgentId));
-  const loading = externalLoading;
+  const [options3, setOptions] = import_react30.useState([]);
+  const [optionsLoading, setOptionsLoading] = import_react30.useState(true);
+  const loading = externalLoading || optionsLoading;
   const [selectedIndex, setSelectedIndex] = import_react30.useState(0);
   const [showAll, setShowAll] = import_react30.useState(false);
   const [selectingModel, setSelectingModel] = import_react30.useState(!!(serverModelsForNewAgent && serverModelsForNewAgent.length > 0));
@@ -546648,45 +546682,45 @@ function ProfileSelectionUI({
   const [modelSearchQuery, setModelSearchQuery] = import_react30.useState("");
   const [modelReasoningPrompt, setModelReasoningPrompt] = import_react30.useState(null);
   const loadOptions = import_react30.useCallback(async () => {
+    setOptionsLoading(true);
     try {
-      const pinned = settingsManager.getPinnedAgents();
-      const optionsToFetch = [];
+      const pinned = await listPinnedAgentsForCurrentUser2();
+      let fetchedOptions = [];
       const seenAgentIds = new Set;
       if (lruAgentId) {
-        optionsToFetch.push({
-          name: null,
-          agentId: lruAgentId,
-          isLru: true,
-          agent: null
-        });
+        const pinnedLru = pinned.find(({ agentId, agent: agent3 }) => agentId === lruAgentId && agent3);
+        let agent2 = pinnedLru?.agent ?? null;
+        if (!agent2) {
+          try {
+            const backend4 = getBackendForMode(isLocalAgentId(lruAgentId) ? "local" : "api");
+            agent2 = await backend4.retrieveAgent(lruAgentId, {
+              include: ["agent.blocks"]
+            });
+          } catch {
+            agent2 = null;
+          }
+        }
+        if (agent2) {
+          fetchedOptions.push({
+            name: agent2.name,
+            agentId: lruAgentId,
+            isLru: true,
+            agent: agent2
+          });
+        }
         seenAgentIds.add(lruAgentId);
       }
-      for (const agentId of pinned) {
-        if (!seenAgentIds.has(agentId)) {
-          optionsToFetch.push({
-            name: null,
+      for (const { agentId, agent: agent2 } of pinned) {
+        if (agent2 && !seenAgentIds.has(agentId)) {
+          fetchedOptions.push({
+            name: agent2.name,
             agentId,
             isLru: false,
-            agent: null
+            agent: agent2
           });
           seenAgentIds.add(agentId);
         }
       }
-      let fetchedOptions = await Promise.all(optionsToFetch.map(async (opt) => {
-        if (opt.agent) {
-          return opt;
-        }
-        try {
-          const backend4 = getBackendForMode(isLocalAgentId(opt.agentId) ? "local" : "api");
-          const agent2 = await backend4.retrieveAgent(opt.agentId, {
-            include: ["agent.blocks"]
-          });
-          return { ...opt, agent: agent2 };
-        } catch {
-          return { ...opt, agent: null };
-        }
-      }));
-      fetchedOptions = fetchedOptions.filter((opt) => opt.agent !== null);
       if (fetchedOptions.length === 0) {
         const recentAgents = await getRecentAgentOptions({
           includeLocal: false,
@@ -546703,14 +546737,15 @@ function ProfileSelectionUI({
       setOptions(fetchedOptions);
     } catch {
       setOptions([]);
+    } finally {
+      setOptionsLoading(false);
     }
   }, [lruAgentId]);
   import_react30.useEffect(() => {
     if (externalLoading)
       return;
-    setOptions((current) => current.length > 0 ? current : buildInitialProfileOptions(lruAgentId));
     loadOptions();
-  }, [externalLoading, loadOptions, lruAgentId]);
+  }, [externalLoading, loadOptions]);
   const displayOptions = showAll ? options3 : options3.slice(0, MAX_DISPLAY);
   const hasMore = options3.length > MAX_DISPLAY;
   const totalItems = displayOptions.length + 1 + (hasMore && !showAll ? 1 : 0);
@@ -547589,8 +547624,8 @@ async function resolveStartupBackendDisplay() {
   }
   const apiKey = process.env.LETTA_API_KEY || settings3.env?.LETTA_API_KEY;
   const baseURL = process.env.LETTA_BASE_URL || settings3.env?.LETTA_BASE_URL || LETTA_CLOUD_API_URL;
-  const hasCloudCredentials = Boolean(apiKey || settings3.refreshToken);
-  if (baseURL === LETTA_CLOUD_API_URL && !hasCloudCredentials) {
+  const hasCloudCredentials3 = Boolean(apiKey || settings3.refreshToken);
+  if (baseURL === LETTA_CLOUD_API_URL && !hasCloudCredentials3) {
     return "setup";
   }
   return "api";
@@ -556327,19 +556362,6 @@ function getModelForToolLoading(specifiedModel, specifiedToolset) {
   }
   return specifiedModel;
 }
-async function findLocalAgentsByName(name) {
-  const backend4 = getBackendForMode("local");
-  const normalizedName = name.toLowerCase();
-  try {
-    const page = await backend4.listAgents({
-      query_text: name,
-      limit: 100
-    });
-    return paginatedItems6(page).filter((agent2) => agent2.name?.toLowerCase() === normalizedName);
-  } catch {
-    return [];
-  }
-}
 function getStartupTargetLookupOrderForCredentials({
   baseURL,
   explicitBackendMode,
@@ -556356,44 +556378,24 @@ function getStartupTargetLookupOrderForCredentials({
 }
 async function resolveAgentByName2(name, backendLookupOrder) {
   const normalizedSearchName = name.toLowerCase();
+  const pinnedAgents = await listPinnedAgentsForCurrentUser(backendLookupOrder);
   for (const backendMode of backendLookupOrder) {
-    const backend4 = getBackendForMode(backendMode);
-    const pinnedAgents = settingsManager2.getPinnedAgentsForBackendMode(backendMode);
-    const matches3 = [];
-    if (pinnedAgents.length > 0) {
-      await Promise.all(pinnedAgents.map(async (id2) => {
-        try {
-          const agent2 = await backend4.retrieveAgent(id2);
-          if (agent2.name?.toLowerCase() === normalizedSearchName) {
-            matches3.push({ id: id2, name: agent2.name, agent: agent2, backendMode });
-          }
-        } catch {}
-      }));
-    }
-    if (backendMode === "local") {
-      const seen = new Set(matches3.map((match4) => match4.id));
-      for (const agent2 of await findLocalAgentsByName(name)) {
-        if (!seen.has(agent2.id)) {
-          matches3.push({
-            id: agent2.id,
-            name: agent2.name ?? agent2.id,
-            agent: agent2,
-            backendMode
-          });
-          seen.add(agent2.id);
-        }
+    const matches3 = pinnedAgents.flatMap((pinned) => pinned.backendMode === backendMode && pinned.agent?.name?.toLowerCase() === normalizedSearchName ? [
+      {
+        id: pinned.agentId,
+        name: pinned.agent.name,
+        agent: pinned.agent,
+        backendMode
       }
-    }
+    ] : []);
     if (matches3.length === 0)
       continue;
     if (matches3.length === 1)
       return matches3[0] ?? null;
-    const localSettings = settingsManager2.getLocalProjectSettings();
-    const localMatch = matches3.find((m4) => m4.id === localSettings.lastAgent);
+    const localMatch = matches3.find((match4) => match4.id === settingsManager2.getLocalLastAgentId());
     if (localMatch)
       return localMatch;
-    const settings3 = settingsManager2.getSettings();
-    const globalMatch = matches3.find((m4) => m4.id === settings3.lastAgent);
+    const globalMatch = matches3.find((match4) => match4.id === settingsManager2.getGlobalLastAgentId());
     if (globalMatch)
       return globalMatch;
     return matches3[0] ?? null;
@@ -556401,18 +556403,8 @@ async function resolveAgentByName2(name, backendLookupOrder) {
   return null;
 }
 async function getPinnedAgentNames(backendLookupOrder) {
-  const agents = [];
-  for (const backendMode of backendLookupOrder) {
-    const backend4 = getBackendForMode(backendMode);
-    const pinnedAgents = settingsManager2.getPinnedAgentsForBackendMode(backendMode);
-    await Promise.all(pinnedAgents.map(async (id2) => {
-      try {
-        const agent2 = await backend4.retrieveAgent(id2);
-        agents.push({ id: id2, name: agent2.name || "(unnamed)" });
-      } catch {}
-    }));
-  }
-  return agents;
+  const pinnedAgents = await listPinnedAgentsForCurrentUser(backendLookupOrder);
+  return pinnedAgents.flatMap(({ agentId, agent: agent2 }) => agent2 ? [{ id: agentId, name: agent2.name || "(unnamed)" }] : []);
 }
 async function resolveConversationAcrossBackends(conversationId, backendLookupOrder) {
   for (const backendMode of backendLookupOrder) {
@@ -557256,54 +557248,54 @@ Error: ${message}`);
           setLoadingState("assembling");
           return;
         }
-        const rawLocalAgentId = settingsManager2.getLocalLastAgentId(process.cwd());
-        const rawGlobalAgentId = settingsManager2.getGlobalLastAgentId();
-        const pinnedAgentIds = settingsManager2.getPinnedAgentsForBackendMode(startupBackendMode);
-        const localAgentId = startupBackendMode === "local" ? rawLocalAgentId : null;
-        const globalAgentId = startupBackendMode === "api" ? rawGlobalAgentId : null;
-        const agentIdsToValidate = [
-          ...new Set([...pinnedAgentIds, localAgentId, globalAgentId].filter((agentId2) => Boolean(agentId2)))
-        ];
-        const validationResults = await Promise.allSettled(agentIdsToValidate.map(async (agentId2) => ({
-          agentId: agentId2,
-          agent: await backend4.retrieveAgent(agentId2, {
-            include: ["agent.tags"]
-          })
-        })));
-        const cachedAgents = new Map;
-        for (const result of validationResults) {
-          if (result.status === "fulfilled") {
-            cachedAgents.set(result.value.agentId, result.value.agent);
-          }
-        }
-        const existingPinnedIds = pinnedAgentIds.filter((id2) => cachedAgents.has(id2));
-        const pinnedAgentId = existingPinnedIds.length === 1 ? existingPinnedIds[0] ?? null : null;
-        const pinnedAgentExists = pinnedAgentId !== null;
-        let localAgentExists = false;
-        let globalAgentExists = false;
+        const localAgentId = settingsManager2.getLocalLastAgentId(process.cwd());
+        const globalAgentId = startupBackendMode === "api" ? settingsManager2.getGlobalLastAgentId() : null;
+        const localSession = settingsManager2.getLocalLastSession(process.cwd());
         if (localAgentId) {
-          localAgentExists = cachedAgents.has(localAgentId);
-          if (!localAgentExists) {
+          try {
+            const localAgent = await backend4.retrieveAgent(localAgentId, {
+              include: ["agent.tags"]
+            });
+            setSelectedGlobalAgentId(localAgentId);
+            setValidatedAgent(localAgent);
+            if (localSession?.conversationId && !forceNewConversation) {
+              setSelectedConversationId(localSession.conversationId);
+            }
+            markMilestone2("STARTUP_LRU_FETCH_DONE");
+            setLoadingState("assembling");
+            return;
+          } catch {
             setFailedAgentMessage(`Unable to locate recently used agent ${localAgentId}`);
           }
         }
-        if (globalAgentId) {
-          globalAgentExists = cachedAgents.has(globalAgentId);
+        const pinnedAgents = await listPinnedAgentsForCurrentUser([
+          startupBackendMode
+        ]);
+        const pinnedAgentIds = pinnedAgents.map(({ agentId: agentId2 }) => agentId2);
+        const cachedAgents = new Map(pinnedAgents.flatMap(({ agentId: agentId2, agent: agent2 }) => agent2 ? [[agentId2, agent2]] : []));
+        if (globalAgentId && !cachedAgents.has(globalAgentId)) {
+          try {
+            const globalAgent = await backend4.retrieveAgent(globalAgentId, {
+              include: ["agent.tags"]
+            });
+            cachedAgents.set(globalAgentId, globalAgent);
+          } catch {}
         }
+        const existingPinnedIds = pinnedAgentIds.filter((id2) => cachedAgents.has(id2));
+        const pinnedAgentId = existingPinnedIds.length === 1 ? existingPinnedIds[0] ?? null : null;
+        const pinnedAgentExists = pinnedAgentId !== null;
+        const globalAgentExists = globalAgentId ? cachedAgents.has(globalAgentId) : false;
         markMilestone2("STARTUP_LRU_FETCH_DONE");
-        const pinnedCount = pinnedAgentIds.length;
-        const existingPinnedCount = existingPinnedIds.length;
-        const fallbackSession = startupBackendMode === "local" && !localAgentExists && !globalAgentExists ? await getLocalBackendStartupFallbackSession(backend4) : null;
+        const fallbackSession = startupBackendMode === "local" && !globalAgentExists ? await getLocalBackendStartupFallbackSession(backend4) : null;
         const { resolveStartupTarget: resolveStartupTarget2 } = await Promise.resolve().then(() => exports_resolve_startup_agent);
-        const localSession = settingsManager2.getLocalLastSession(process.cwd());
         const target2 = resolveStartupTarget2({
           pinnedAgentId,
           pinnedAgentExists,
-          pinnedCount,
-          existingPinnedCount,
+          pinnedCount: pinnedAgentIds.length,
+          existingPinnedCount: existingPinnedIds.length,
           localAgentId,
           localConversationId: localSession?.conversationId ?? null,
-          localAgentExists,
+          localAgentExists: false,
           globalAgentId,
           globalAgentExists,
           fallbackAgentId: fallbackSession?.agentId ?? null,
@@ -557872,4 +557864,4 @@ Error during initialization: ${message}`);
 }
 main2();
 
-//# debugId=34462D9552FF5A1A64756E2164756E21
+//# debugId=8849A89953C6484464756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.28.12",
+  "version": "0.28.13",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "packageManager": "bun@1.3.0",

package/scripts/source-file-size-baseline.json

@@ -11,7 +11,7 @@
   "src/cli/app/use-configuration-handlers.ts": 1392,
   "src/cli/app/use-conversation-loop.ts": 2935,
   "src/cli/app/use-submit-handler.ts": 4099,
-  "src/cli/components/AgentSelector.tsx": 1270,
+  "src/cli/components/AgentSelector.tsx": 1151,
   "src/cli/components/InputRich.tsx": 2219,
   "src/cli/components/ModelSelector.tsx": 1204,
   "src/cli/components/ProviderSelector.tsx": 1676,
@@ -24,7 +24,7 @@
   "src/cli/subcommands/skills.ts": 1264,
   "src/headless.ts": 5242,
   "src/hooks/integration.test.ts": 1147,
-  "src/index.ts": 2866,
+  "src/index.ts": 2803,
   "src/mods/learning-harness.ts": 2434,
   "src/mods/mod-engine.test.ts": 2178,
   "src/mods/mod-engine.ts": 1879,