@alpaca-editor/core 1.0.4049 → 1.0.4052

package/src/editor/services/agentService.ts

@@ -1,10 +1,11 @@
-import { AiContext, Message } from "../ai/AiTerminal";
+import { Message } from "../ai/AiTerminal";
+import { get, post } from "./serviceHelper";
 
 export const AGENT_BASE_URL = "/alpaca/editor/agent";
 
 export interface StartAgentRequest {
   agentId: string;
-  messages: any[];
+  message: string;
   sessionId: string;
   profileId: string;
   model?: string;
@@ -34,22 +35,26 @@ export interface AgentStreamMessage {
   error?: string;
 }
 
-export enum AgentStreamMessageType {
-  StatusUpdate = "StatusUpdate",
-  ContentChunk = "ContentChunk",
-  ToolCall = "ToolCall",
-  ToolResult = "ToolResult",
-  EditOperations = "EditOperations",
-  Completed = "Completed",
-  Error = "Error",
-}
+export type AgentStreamMessageType =
+  | "statusUpdate"
+  | "contentChunk"
+  | "toolCall"
+  | "toolResult"
+  | "editOperations"
+  | "completed"
+  | "error";
+
+export type AgentStatus = "new" | "running" | "closed" | "cancelled";
 
-export interface AgentChat {
+export type Agent = {
   id: string;
   name: string;
-  sessionId: string;
   userId: string;
-  userDisplayName: string;
+  updatedDate: string;
+  status: AgentStatus;
+};
+
+export type AgentDetails = Agent & {
   itemId: string;
   itemPath: string;
   language: string;
@@ -57,9 +62,9 @@ export interface AgentChat {
   profileId?: string;
   profileName: string;
   model: string;
-  status: string;
+
   createdDate: string;
-  updatedDate: string;
+
   lastMessageDate?: string;
   totalTokensUsed: number;
   totalInputTokens: number;
@@ -73,7 +78,7 @@ export interface AgentChat {
   messageCount: number;
   metadata?: string;
   messages?: AgentChatMessage[];
-}
+};
 
 export interface AgentChatMessage {
   id: string;
@@ -121,23 +126,19 @@ export interface AgentChatToolCall {
  */
 export async function startAgent(
   request: StartAgentRequest,
-  context: AiContext,
 ): Promise<StartAgentResponse> {
-  const response = await fetch(AGENT_BASE_URL + "/start", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(request),
-  });
-
-  if (!response.ok) {
+  const result = await post<StartAgentResponse>(
+    AGENT_BASE_URL + "/start",
+    request,
+  );
+
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to start agent: ${response.status} ${response.statusText}`,
+      `Failed to start agent: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data!;
 }
 
 /**
@@ -145,7 +146,6 @@ export async function startAgent(
  */
 export async function connectToAgentStream(
   agentId: string,
-  context: AiContext,
   onMessage: (message: AgentStreamMessage) => void,
   signal?: AbortSignal,
 ): Promise<void> {
@@ -255,25 +255,25 @@ async function processEventStream(
                 const originalType = message.type;
                 switch (message.type) {
                   case 0:
-                    message.type = AgentStreamMessageType.StatusUpdate;
+                    message.type = "statusUpdate";
                     break;
                   case 1:
-                    message.type = AgentStreamMessageType.ContentChunk;
+                    message.type = "contentChunk";
                     break;
                   case 2:
-                    message.type = AgentStreamMessageType.ToolCall;
+                    message.type = "toolCall";
                     break;
                   case 3:
-                    message.type = AgentStreamMessageType.ToolResult;
+                    message.type = "toolResult";
                     break;
                   case 4:
-                    message.type = AgentStreamMessageType.EditOperations;
+                    message.type = "editOperations";
                     break;
                   case 5:
-                    message.type = AgentStreamMessageType.Completed;
+                    message.type = "completed";
                     break;
                   case 6:
-                    message.type = AgentStreamMessageType.Error;
+                    message.type = "error";
                     break;
                   default:
                     message.type = `Unknown_${message.type}`;
@@ -283,17 +283,14 @@ async function processEventStream(
               onMessage(message);
 
               // Break on completion or error
-              if (
-                message.type === AgentStreamMessageType.Completed ||
-                message.type === AgentStreamMessageType.Error
-              ) {
+              if (message.type === "completed" || message.type === "error") {
                 return;
               }
             }
           } catch (error) {
             // Send error message to the client to notify user
             onMessage({
-              type: AgentStreamMessageType.Error,
+              type: "error",
               error: `Failed to parse stream message: ${error instanceof Error ? error.message : "Unknown parsing error"}`,
               data: null,
               timestamp: new Date().toISOString(),
@@ -312,209 +309,140 @@ async function processEventStream(
 /**
  * Gets the current status of an agent execution
  */
-export async function getAgentStatus(
-  agentId: string,
-  context: AiContext,
-): Promise<any> {
-  const response = await fetch(
+export async function getAgentStatus(agentId: string): Promise<any> {
+  const result = await get<any>(
     AGENT_BASE_URL + "/getAgentStatus?agentId=" + agentId,
-    {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    },
   );
 
-  if (!response.ok) {
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to get agent status: ${response.status} ${response.statusText}`,
+      `Failed to get agent status: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data;
 }
 
 /**
  * Gets all currently running agents for monitoring
  */
-export async function getRunningAgents(context: AiContext): Promise<any> {
-  const response = await fetch(AGENT_BASE_URL + "/getRunningAgents", {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
-
-  if (!response.ok) {
+export async function getRunningAgents(): Promise<any> {
+  const result = await get<any>(AGENT_BASE_URL + "/getRunningAgents");
+
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to get running agents: ${response.status} ${response.statusText}`,
+      `Failed to get running agents: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data;
 }
 
 /**
  * Gets a single agent by ID with complete message history and cost information
  */
-export async function getAgent(
-  agentId: string,
-  context: AiContext,
-): Promise<any> {
-  const response = await fetch(
+export async function getAgent(agentId: string): Promise<AgentDetails> {
+  const result = await get<AgentDetails>(
     AGENT_BASE_URL + "/getAgent?agentId=" + agentId,
-    {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    },
   );
 
-  if (!response.ok) {
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to get agent: ${response.status} ${response.statusText}`,
+      `Failed to get agent: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data!;
 }
 
 /**
  * Gets all agents for the current user
  */
-export async function getAgents(
-  context: AiContext,
-  status?: string,
-  limit?: number,
-): Promise<any> {
+export async function getActiveAgents(limit?: number): Promise<Agent[]> {
   const params = new URLSearchParams();
-  if (status) params.append("status", status);
   if (limit) params.append("limit", limit.toString());
 
   const queryString = params.toString();
   const url =
     AGENT_BASE_URL + "/getAgents" + (queryString ? `?${queryString}` : "");
 
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
+  const result = await get<Agent[]>(url);
 
-  if (!response.ok) {
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to get agents: ${response.status} ${response.statusText}`,
+      `Failed to get active agents: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data || [];
 }
 
 /**
- * Gets chat history for the current user
+ * Gets all closed agents for the current user
  */
-export async function getChatHistory(
-  context: AiContext,
-  status?: string,
-  limit?: number,
-): Promise<any> {
+export async function getClosedAgents(limit?: number): Promise<Agent[]> {
   const params = new URLSearchParams();
-  if (status) params.append("status", status);
+  params.append("status", "closed");
   if (limit) params.append("limit", limit.toString());
 
   const queryString = params.toString();
   const url =
-    AGENT_BASE_URL + "/chatHistory" + (queryString ? `?${queryString}` : "");
+    AGENT_BASE_URL + "/getAgents" + (queryString ? `?${queryString}` : "");
 
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
+  const result = await get<Agent[]>(url);
 
-  if (!response.ok) {
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to get chat history: ${response.status} ${response.statusText}`,
+      `Failed to get closed agents: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data || [];
 }
 
 /**
  * Cancels a running agent execution
  */
-export async function cancelAgent(
-  agentId: string,
-  context: AiContext,
-): Promise<any> {
-  const response = await fetch(AGENT_BASE_URL + "/cancel", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ agentId }),
-  });
-
-  if (!response.ok) {
+export async function cancelAgent(agentId: string): Promise<any> {
+  const result = await post<any>(AGENT_BASE_URL + "/cancel", { agentId });
+
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to cancel agent: ${response.status} ${response.statusText}`,
+      `Failed to cancel agent: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data;
 }
 
 /**
  * Permanently deletes an agent and all its messages
  */
-export async function deleteAgent(
-  agentId: string,
-  context: AiContext,
-): Promise<any> {
-  const response = await fetch(AGENT_BASE_URL + "/deleteAgent", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ agentId }),
-  });
-
-  if (!response.ok) {
+export async function deleteAgent(agentId: string): Promise<any> {
+  const result = await post<any>(AGENT_BASE_URL + "/deleteAgent", { agentId });
+
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to delete agent: ${response.status} ${response.statusText}`,
+      `Failed to delete agent: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data;
 }
 
 /**
  * Closes an agent by canceling execution and setting status to closed
  */
-export async function closeAgent(
-  agentId: string,
-  context: AiContext,
-): Promise<any> {
-  const response = await fetch(AGENT_BASE_URL + "/closeAgent", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ agentId }),
-  });
-
-  if (!response.ok) {
+export async function closeAgent(agentId: string): Promise<any> {
+  const result = await post<any>(AGENT_BASE_URL + "/closeAgent", { agentId });
+
+  if (result.type !== "success") {
     throw new Error(
-      `Failed to close agent: ${response.status} ${response.statusText}`,
+      `Failed to close agent: ${result.summary || "Unknown error"} ${result.details || ""}`,
     );
   }
 
-  return await response.json();
+  return result.data;
 }
 
 /**
@@ -522,12 +450,11 @@ export async function closeAgent(
  */
 export async function checkAgentState(
   agentId: string,
-  context: AiContext,
-): Promise<{ exists: boolean; agent?: AgentChat; isRunning: boolean }> {
+): Promise<{ exists: boolean; agent?: Agent; isRunning: boolean }> {
   try {
-    const agent = await getAgent(agentId, context);
+    const agent = await getAgent(agentId);
 
-    const isRunning = agent.status === 0;
+    const isRunning = agent.status === "running";
 
     return {
       exists: true,

package/src/editor/sidebar/GraphQL.tsx

@@ -197,6 +197,7 @@ export function GraphQL() {
 
     return {
       ...baseContext,
+      endpoint: "/alpaca/editor/graphql/prompt",
       promptData: {
         ...baseContext.promptData,
         graphqlSchema: schemaResult?.data || null,

package/src/editor/sidebar/ViewSelector.tsx

@@ -20,30 +20,34 @@ import { DrawingPinFilledIcon, DrawingPinIcon } from "@radix-ui/react-icons";
 
 function ViewSelectorComponent() {
   const editContext = useEditContext();
-  
+
   // Extract and memoize specific values to prevent unnecessary re-renders
-  const contextValues = useMemo(() => ({
-    userViews: editContext?.userInfo.views,
-    pinnedViews: editContext?.userInfo.preferences?.pinnedViews ||
-      editContext?.configuration.editor.defaultPinnedViews ||
-      [],
-    showViewNames: editContext?.userInfo.preferences?.showViewNames ?? false,
-    viewName: editContext?.viewName,
-    isMobile: editContext?.isMobile,
-    views: editContext?.configuration.editor.views,
-    switchView: editContext?.switchView,
-    setUserPreferences: editContext?.setUserPreferences
-  }), [
-    editContext?.userInfo.views,
-    editContext?.userInfo.preferences?.pinnedViews,
-    editContext?.configuration.editor.defaultPinnedViews,
-    editContext?.userInfo.preferences?.showViewNames,
-    editContext?.viewName,
-    editContext?.isMobile,
-    editContext?.configuration.editor.views,
-    editContext?.switchView,
-    editContext?.setUserPreferences
-  ]);
+  const contextValues = useMemo(
+    () => ({
+      userViews: editContext?.userInfo.views,
+      pinnedViews:
+        editContext?.userInfo.preferences?.pinnedViews ||
+        editContext?.configuration.editor.defaultPinnedViews ||
+        [],
+      showViewNames: editContext?.userInfo.preferences?.showViewNames ?? false,
+      viewName: editContext?.viewName,
+      isMobile: editContext?.isMobile,
+      views: editContext?.configuration.editor.views,
+      switchView: editContext?.switchView,
+      setUserPreferences: editContext?.setUserPreferences,
+    }),
+    [
+      editContext?.userInfo.views,
+      editContext?.userInfo.preferences?.pinnedViews,
+      editContext?.configuration.editor.defaultPinnedViews,
+      editContext?.userInfo.preferences?.showViewNames,
+      editContext?.viewName,
+      editContext?.isMobile,
+      editContext?.configuration.editor.views,
+      editContext?.switchView,
+      editContext?.setUserPreferences,
+    ],
+  );
 
   const [isPopoverOpen, setIsPopoverOpen] = useState(false);
 
@@ -52,11 +56,13 @@ function ViewSelectorComponent() {
       contextValues.views
         ?.filter(
           (x) =>
-            (x.visible && editContext && x.visible(editContext)) || (!x.visible && !x.hidden),
+            (x.visible && editContext && x.visible(editContext)) ||
+            (!x.visible && !x.hidden),
         )
         .filter(
           (x) =>
-            !contextValues.userViews || contextValues.userViews.map((view) => view.name).includes(x.name),
+            !contextValues.userViews ||
+            contextValues.userViews.map((view) => view.name).includes(x.name),
         ) ?? []
     );
   }, [contextValues.views, contextValues.userViews, editContext]);
@@ -64,14 +70,17 @@ function ViewSelectorComponent() {
   // Use visibleViews from editContext instead of calculating locally
   const visibleViews = editContext?.visibleViews ?? [];
 
-  const togglePin = useCallback((viewName: string) => {
-    const newPinnedViews = contextValues.pinnedViews.includes(viewName)
-      ? contextValues.pinnedViews.filter((name) => name !== viewName)
-      : [...contextValues.pinnedViews, viewName];
+  const togglePin = useCallback(
+    (viewName: string) => {
+      const newPinnedViews = contextValues.pinnedViews.includes(viewName)
+        ? contextValues.pinnedViews.filter((name) => name !== viewName)
+        : [...contextValues.pinnedViews, viewName];
 
-    // Save to user preferences via editContext
-    contextValues.setUserPreferences?.({ pinnedViews: newPinnedViews });
-  }, [contextValues.pinnedViews, contextValues.setUserPreferences]);
+      // Save to user preferences via editContext
+      contextValues.setUserPreferences?.({ pinnedViews: newPinnedViews });
+    },
+    [contextValues.pinnedViews, contextValues.setUserPreferences],
+  );
 
   const toggleShowNames = useCallback(() => {
     const newShowNames = !contextValues.showViewNames;
@@ -79,30 +88,42 @@ function ViewSelectorComponent() {
     contextValues.setUserPreferences?.({ showViewNames: newShowNames });
   }, [contextValues.showViewNames, contextValues.setUserPreferences]);
 
-  const renderViewIcon = useCallback((view: any, additionalClassName?: string) => {
-    if (view.icon && React.isValidElement(view.icon)) {
-      return React.cloneElement(view.icon as React.ReactElement<any>, {
-        className: cn("w-5 h-5", additionalClassName),
-      });
-    }
-    return null;
-  }, []);
-
-  const handleViewClick = useCallback((viewName: string) => {
-    if (viewName !== contextValues.viewName) {
-      contextValues.switchView?.(viewName);
-    }
-  }, [contextValues.viewName, contextValues.switchView]);
+  const renderViewIcon = useCallback(
+    (view: any, additionalClassName?: string) => {
+      if (view.icon && React.isValidElement(view.icon)) {
+        return React.cloneElement(view.icon as React.ReactElement<any>, {
+          className: cn("w-5 h-5", additionalClassName),
+        });
+      }
+      return null;
+    },
+    [],
+  );
 
-  const handleViewClickAndClosePopover = useCallback((viewName: string) => {
-    contextValues.switchView?.(viewName);
-    setIsPopoverOpen(false);
-  }, [contextValues.switchView]);
+  const handleViewClick = useCallback(
+    (viewName: string) => {
+      if (viewName !== contextValues.viewName) {
+        contextValues.switchView?.(viewName);
+      }
+    },
+    [contextValues.viewName, contextValues.switchView],
+  );
 
-  const handlePinClick = useCallback((e: React.MouseEvent, viewName: string) => {
-    e.stopPropagation();
-    togglePin(viewName);
-  }, [togglePin]);
+  const handleViewClickAndClosePopover = useCallback(
+    (viewName: string) => {
+      contextValues.switchView?.(viewName);
+      setIsPopoverOpen(false);
+    },
+    [contextValues.switchView],
+  );
+
+  const handlePinClick = useCallback(
+    (e: React.MouseEvent, viewName: string) => {
+      e.stopPropagation();
+      togglePin(viewName);
+    },
+    [togglePin],
+  );
 
   return (
     <TooltipProvider>
@@ -110,7 +131,7 @@ function ViewSelectorComponent() {
       {visibleViews
         .filter((x) => x.icon)
         .map((view, i) => (
-          <Tooltip key={`visible-${i}`}>
+          <Tooltip key={`visible-${i}`} delayDuration={500}>
             <TooltipTrigger asChild>
               <div
                 className={classNames(
@@ -158,7 +179,7 @@ function ViewSelectorComponent() {
                   <VerticalDotsIcon />
                 </Button>
               </PopoverTrigger>
-            </TooltipTrigger >
+            </TooltipTrigger>
             <TooltipContent side="right">More views</TooltipContent>
           </Tooltip>
           <PopoverContent
@@ -229,7 +250,11 @@ function ViewSelectorComponent() {
             )}
             onClick={toggleShowNames}
           >
-            {contextValues.showViewNames ? <ViewToggleIcon /> : <ViewToggleIcon />}
+            {contextValues.showViewNames ? (
+              <ViewToggleIcon />
+            ) : (
+              <ViewToggleIcon />
+            )}
           </Button>
         </TooltipTrigger>
         <TooltipContent>

package/src/editor/ui/Section.tsx

@@ -1,5 +1,5 @@
 import { classNames } from "primereact/utils";
-import { useLocalStorage } from "../utils";
+import { useCollapsedSections } from "../utils";
 import { ChevronDown } from "lucide-react";
 
 export function Section({
@@ -9,7 +9,8 @@ export function Section({
   title: string;
   children: React.ReactNode;
 }) {
-  const [open, setOpen] = useLocalStorage("editor.showSection-" + title, true);
+  const { isSectionCollapsed, toggleSection } = useCollapsedSections();
+  const open = !isSectionCollapsed(title);
 
   return (
     <div>
@@ -20,7 +21,7 @@ export function Section({
             : "border-gray-400 bg-gray-400 hover:border-gray-300 hover:bg-gray-500",
           "flex cursor-pointer items-center justify-between border-l-[7px] px-3 py-2 text-xs text-white transition-all duration-200 ease-in-out",
         )}
-        onClick={() => setOpen(!open)}
+        onClick={() => toggleSection(title)}
       >
         {title}
         <ChevronDown