@alpaca-editor/core 1.0.4176 → 1.0.4179

package/src/editor/services/agentService.ts

@@ -75,9 +75,18 @@ export type AgentStatus =
 export type Agent = {
   id: string;
   name: string;
+  description?: string;
   userId: string;
   updatedDate: string;
   status: AgentStatus;
+  isShared?: boolean;
+  ownerName?: string;
+  profileId?: string;
+  profileName?: string;
+  profileSvgIcon?: string;
+  messageCount?: number;
+  totalCost?: number;
+  totalTokensUsed?: number;
 };
 
 export type AgentDetails = Agent & {
@@ -494,18 +503,43 @@ export async function getAgent(agentId: string): Promise<AgentDetails> {
   return result.data!;
 }
 
+export interface GetAgentsParams {
+  skip?: number;
+  limit?: number;
+  includeShared?: boolean;
+  includeOwned?: boolean;
+  searchTerm?: string;
+}
+
+export interface GetAgentsResponse {
+  agents: Agent[];
+  totalCount: number;
+  hasMore: boolean;
+}
+
 /**
- * Gets all agents for the current user
+ * Gets all agents for the current user with pagination and search support
  */
-export async function getActiveAgents(limit?: number): Promise<Agent[]> {
-  const params = new URLSearchParams();
-  if (limit) params.append("limit", limit.toString());
-
-  const queryString = params.toString();
+export async function getActiveAgents(
+  params?: GetAgentsParams,
+): Promise<GetAgentsResponse> {
+  const queryParams = new URLSearchParams();
+
+  if (params?.skip !== undefined)
+    queryParams.append("skip", params.skip.toString());
+  if (params?.limit !== undefined)
+    queryParams.append("limit", params.limit.toString());
+  if (params?.includeShared !== undefined)
+    queryParams.append("includeShared", params.includeShared.toString());
+  if (params?.includeOwned !== undefined)
+    queryParams.append("includeOwned", params.includeOwned.toString());
+  if (params?.searchTerm) queryParams.append("searchTerm", params.searchTerm);
+
+  const queryString = queryParams.toString();
   const url =
     AGENT_BASE_URL + "/getAgents" + (queryString ? `?${queryString}` : "");
 
-  const result = await get<Agent[]>(url);
+  const result = await get<GetAgentsResponse>(url);
 
   if (result.type !== "success") {
     throw new Error(
@@ -513,30 +547,27 @@ export async function getActiveAgents(limit?: number): Promise<Agent[]> {
     );
   }
 
-  return result.data || [];
+  return result.data || { agents: [], totalCount: 0, hasMore: false };
 }
 
 /**
  * Gets all closed agents for the current user
+ * @deprecated Use getActiveAgents() instead - the backend now returns all agents (including closed) by default
  */
 export async function getClosedAgents(limit?: number): Promise<Agent[]> {
-  const params = new URLSearchParams();
-  params.append("status", "closed");
-  if (limit) params.append("limit", limit.toString());
-
-  const queryString = params.toString();
-  const url =
-    AGENT_BASE_URL + "/getAgents" + (queryString ? `?${queryString}` : "");
-
-  const result = await get<Agent[]>(url);
+  // Use the new endpoint format which returns all agents including closed ones
+  const response = await getActiveAgents({
+    limit: limit || 1000,
+    includeShared: false, // Only get user's own closed agents
+    includeOwned: true,
+  });
 
-  if (result.type !== "success") {
-    throw new Error(
-      `Failed to get closed agents: ${result.summary || "Unknown error"} ${result.details || ""}`,
-    );
-  }
+  // Filter to only closed agents on the client side
+  const closedAgents = response.agents.filter(
+    (agent) => agent.status === "closed" || agent.status === 5, // 5 is the numeric value for Closed
+  );
 
-  return result.data || [];
+  return closedAgents;
 }
 
 /**

package/src/editor/services/aiService.ts

@@ -362,11 +362,16 @@ function parseJsonContent<T>(content: string): T {
     }
   }
 
-  // Apply JsonCleaner to handle incomplete JSON during streaming
-  const cleanupResult = JsonCleaner.cleanupJson(cleanedContent);
-  console.log("CLEANED CONTENT: ", cleanupResult.cleanedJson);
+  // Replace JavaScript undefined with JSON null
+  // Pattern matches: undefined as a value (not inside strings)
+  cleanedContent = cleanedContent.replace(
+    /:\s*undefined\s*([,\}])/g,
+    ": null$1",
+  );
 
-  return JSON.parse(cleanupResult.cleanedJson) as T;
+  // Content is already cleaned by executePrompt for streaming responses
+  // and by backend for non-streaming responses, so just parse it
+  return JSON.parse(cleanedContent) as T;
 }
 
 /**
@@ -404,7 +409,8 @@ export async function executePromptWithJsonResult<T = any>(
           const parsed = parseJsonContent<T>(response.content);
           callback(parsed);
         } catch (parseError) {
-          console.error("Error parsing JSON in callback:", parseError);
+          // During streaming, JSON may still be incomplete even after cleaning
+          // Only invoke callback when we have valid parseable JSON
         }
       }
     : undefined;
@@ -438,9 +444,13 @@ export async function generateImage(
     prompt: string;
     sessionId: string;
     pageItem: ItemDescriptor;
+    wizardId: ItemDescriptor;
   },
 ): Promise<ExecutionResult<any>> {
-  const response = await post("/alpaca/editor/agent/generateImage", options);
+  const response = await post(
+    "/alpaca/editor/page-wizard/generateImage",
+    options,
+  );
   return response;
 }
 export async function requestQuota() {

package/src/page-wizard/steps/ContentStep.tsx

@@ -21,10 +21,7 @@ import { convertPageSchemaToWizardComponents } from "./schema";
 import { WizardPageModel } from "../PageWizard";
 import { createWizardAiContext, wipeComponents } from "../service";
 
-import {
-  executePrompt,
-  executePromptWithJsonResult,
-} from "../../editor/services/aiService";
+import { executePromptWithJsonResult } from "../../editor/services/aiService";
 import { usePageCreator } from "./usePageCreator";
 import { useThrottledCallback } from "use-debounce";
 import { Textarea } from "../../components/ui/textarea";
@@ -735,6 +732,13 @@ export function ContentStep({
 
         pageLoadedRef.current = false;
 
+        // Reload the current page item to ensure we stay on the same page
+        if (currentPageItem) {
+          editContextRef.current?.loadItem(getItemDescriptor(currentPageItem), {
+            addToBrowseHistory: false,
+          });
+        }
+
         editContextRef.current?.requestRefresh("immediate");
         await waitForPageLoaded();
         console.log("Page loaded after wipe");
@@ -793,6 +797,7 @@ export function ContentStep({
             Generate a descriptive name for each component including the topic.
               Only use component types that are in the page schema.
               Keep existing components with their ids. Leave id field empty for new components.
+              To generate images write generate: <keywords> into the picture / image field value.
             ${(existingPageModel && `Existing page model: ${JSON.stringify(existingPageModel)}`) || ""}
           Fill empty fields of existing components before you insert new components. Page fields: ${JSON.stringify(
             schema.pageFields.map((f: SchemaField) => {

package/src/page-wizard/steps/SelectStep.tsx

@@ -125,7 +125,7 @@ export function SelectStep({
 
       // Call the executePromptWithJsonResult function with the prompt
       const abortController = new AbortController();
-      const options = await executePromptWithJsonResult<Option[]>(
+      const result = await executePromptWithJsonResult<Option[] | Response>(
         [
           {
             content: `You are a helpful assistant that generates options for a wizard select step.
@@ -150,11 +150,16 @@ Create ${step.fields.numberOfOptions || 5} relevant options.`,
         { signal: abortController.signal },
       );
 
+      // Handle both array and object responses
+      const optionsArray = Array.isArray(result)
+        ? result
+        : (result as Response)?.options || [];
+
       // Set the parsed options
-      setOptions(options);
+      setOptions(optionsArray);
       setInternalState((state: any) => ({
         ...state,
-        [step.id + "options"]: options,
+        [step.id + "options"]: optionsArray,
       }));
     } catch (err) {
       const errorMessage =

package/src/page-wizard/steps/usePageCreator.ts

@@ -343,6 +343,11 @@ export function usePageCreator(
                 prompt: rawValue,
                 sessionId: editContext.sessionId,
                 pageItem: getItemDescriptor(pageItem),
+                wizardId: {
+                  id: wizard.id,
+                  language: pageItem.language,
+                  version: pageItem.version,
+                },
               });
             } else {
               if (rawValue.startsWith("id:")) {

package/src/revision.ts

@@ -1,2 +1,2 @@
-export const version = "1.0.4176";
-export const buildDate = "2025-10-21 14:26:44";
+export const version = "1.0.4179";
+export const buildDate = "2025-10-21 20:54:41";