@alpaca-editor/core 1.0.4174 → 1.0.4177

package/src/editor/services/agentService.ts

@@ -169,12 +169,16 @@ export type AgentContextData = {
       name?: string;
     };
   }>;
-  /** @deprecated Use components instead to get page information per component */
-  componentIds?: string[];
   field?: {
     fieldId: string;
-    itemId: string;
-    name?: string;
+    fieldName?: string;
+    item?: {
+      id: string;
+      language: string;
+      version: number;
+      path?: string;
+      name?: string;
+    };
   };
   comment?: {
     id: string;
@@ -842,71 +846,63 @@ export function canonicalizeAgentMetadata(
     }
   }
 
-  // Process pages (legacy) and items
+  // Process items
   const allPages: any[] = [];
-  if (Array.isArray(m.pages)) allPages.push(...m.pages); // legacy
   if (Array.isArray(m.items)) allPages.push(...m.items);
   for (const ctx of contextSources) {
-    if (Array.isArray(ctx.pages)) allPages.push(...ctx.pages); // legacy
     if (Array.isArray(ctx.items)) allPages.push(...ctx.items);
   }
   if (allPages.length > 0) {
     const dedup: any[] = [];
     const seen = new Set<string>();
     for (const p of allPages) {
-      const id = p?.id ?? p?.Id;
+      const id = p?.id;
       if (!id) continue;
-      const lang = (p?.language ?? p?.Language ?? "").toString();
-      const ver = (p?.version ?? p?.Version ?? "").toString();
+      const lang = (p?.language ?? "").toString();
+      const ver = (p?.version ?? "").toString();
       const key = `${String(id)}-${lang}-${ver}`.toLowerCase();
       if (seen.has(key)) continue;
       seen.add(key);
       dedup.push({
         id: String(id),
-        language: p?.language ?? p?.Language,
-        version: p?.version ?? p?.Version,
-        name: p?.name ?? p?.Name,
-        path: p?.path ?? p?.Path,
+        language: p?.language,
+        version: p?.version,
+        name: p?.name,
+        path: p?.path,
       });
     }
     m.items = dedup;
   } else {
-    // Clear both if no items
     delete m.items;
   }
 
-  // Delete legacy pages property to avoid sending both
-  delete m.pages;
-
-  // Process components with page info (new structure)
+  // Process components with page info
   const allComponents: any[] = [];
   if (Array.isArray(m.components)) allComponents.push(...m.components);
-  if (Array.isArray(m.Components)) allComponents.push(...m.Components);
   for (const ctx of contextSources) {
     if (Array.isArray(ctx.components)) allComponents.push(...ctx.components);
-    if (Array.isArray(ctx.Components)) allComponents.push(...ctx.Components);
   }
   if (allComponents.length > 0) {
     const dedup: any[] = [];
     const seen = new Set<string>();
     for (const c of allComponents) {
       if (!c) continue;
-      const componentId = c.componentId ?? c.ComponentId ?? c.id ?? c.Id;
+      const componentId = c.componentId;
       if (!componentId || typeof componentId !== "string") continue;
       const key = componentId.toLowerCase();
       if (seen.has(key)) continue;
       seen.add(key);
 
-      const pageItem = c.pageItem ?? c.PageItem;
+      const pageItem = c.pageItem;
       dedup.push({
         componentId: String(componentId),
         pageItem: pageItem
           ? {
-              id: String(pageItem.id ?? pageItem.Id ?? ""),
-              language: pageItem.language ?? pageItem.Language,
-              version: pageItem.version ?? pageItem.Version,
-              name: pageItem.name ?? pageItem.Name,
-              path: pageItem.path ?? pageItem.Path,
+              id: String(pageItem.id ?? ""),
+              language: pageItem.language,
+              version: pageItem.version,
+              name: pageItem.name,
+              path: pageItem.path,
             }
           : undefined,
       });
@@ -914,35 +910,25 @@ export function canonicalizeAgentMetadata(
     m.components = dedup;
   }
 
-  // Process componentIds (legacy - for backward compatibility)
-  const allComponentIds: any[] = [];
-  if (Array.isArray(m.componentIds)) allComponentIds.push(...m.componentIds);
+  // Process field - merge/complete from context sources if needed
   for (const ctx of contextSources) {
-    if (Array.isArray(ctx.componentIds))
-      allComponentIds.push(...ctx.componentIds);
-  }
-  if (allComponentIds.length > 0) {
-    const ids = allComponentIds
-      .map((x) => (typeof x === "string" ? x : (x?.id ?? x?.Id)))
-      .filter((x): x is string => !!x && typeof x === "string");
-    m.componentIds = Array.from(new Set(ids));
-  }
-
-  // Process field
-  if (!m.field) {
-    for (const ctx of contextSources) {
-      if (ctx.field) {
+    if (ctx.field) {
+      // If field doesn't exist, create it from context
+      if (!m.field) {
         m.field = {
-          fieldId:
-            ctx.field.fieldId ??
-            ctx.field.FieldId ??
-            ctx.field.id ??
-            ctx.field.Id,
-          itemId: ctx.field.itemId ?? ctx.field.ItemId,
-          name: ctx.field.name ?? ctx.field.Name,
+          fieldId: ctx.field.fieldId,
+          fieldName: ctx.field.fieldName,
+          item: ctx.field.item,
         };
         break;
       }
+      // If field exists but is incomplete, fill in missing properties
+      if (m.field && !m.field.item && ctx.field.item) {
+        m.field.item = ctx.field.item;
+      }
+      if (m.field && !m.field.fieldName && ctx.field.fieldName) {
+        m.field.fieldName = ctx.field.fieldName;
+      }
     }
   }
 
@@ -967,9 +953,6 @@ export function canonicalizeAgentMetadata(
   }
 
   m.additionalData = Object.keys(additional).length ? additional : undefined;
-  if (Object.prototype.hasOwnProperty.call(m, "AdditionalData")) {
-    delete m.AdditionalData;
-  }
 
   return m as AgentContextData;
 }

package/src/editor/services/aiService.ts

@@ -86,7 +86,8 @@ type Message = {
 
 export interface ExecutePromptResponse {
   editOperations: any[];
-  messages: Message[];
+  content: string;
+  messages?: Message[];
   numInputTokens: number;
   numOutputTokens: number;
   numCachedTokens: number;
@@ -184,23 +185,25 @@ export async function executePrompt(
   };
 
   // Use migrated endpoint under agent controller
-  const endpoint = options.endpoint || "/alpaca/editor/agent/prompt";
+  const endpoint = options.endpoint || "/alpaca/editor/page-wizard/prompt";
 
   const response = await fetch(endpoint, finalRequestOptions);
 
   if (!response.ok) {
     // Always return rich error format
     const text = await response.text();
+    const errorContent = "There was an error processing your request: " + text;
     return {
       messages: [
         {
-          content: "There was an error processing your request: " + text,
+          content: errorContent,
           name: "assistant",
           role: "assistant",
           id: crypto.randomUUID(),
           tool_calls: [],
         },
       ],
+      content: errorContent,
       editOperations: [],
       numInputTokens: 0,
       numOutputTokens: 0,
@@ -330,6 +333,110 @@ export async function executePrompt(
   return result;
 }
 
+/**
+ * Helper function to parse JSON content from AI response
+ * Strips markdown code blocks if present and parses the JSON
+ * Handles incomplete markdown blocks during streaming
+ */
+function parseJsonContent<T>(content: string): T {
+  let cleanedContent = content;
+
+  // Strip markdown code blocks if present
+  if (cleanedContent.startsWith("```json")) {
+    // Remove the opening ```json
+    cleanedContent = cleanedContent.substring(7).trim();
+    // Remove the closing ``` if present
+    if (cleanedContent.endsWith("```")) {
+      cleanedContent = cleanedContent
+        .substring(0, cleanedContent.length - 3)
+        .trim();
+    }
+  } else if (cleanedContent.startsWith("```")) {
+    // Remove the opening ```
+    cleanedContent = cleanedContent.substring(3).trim();
+    // Remove the closing ``` if present
+    if (cleanedContent.endsWith("```")) {
+      cleanedContent = cleanedContent
+        .substring(0, cleanedContent.length - 3)
+        .trim();
+    }
+  }
+
+  // Replace JavaScript undefined with JSON null
+  // Pattern matches: undefined as a value (not inside strings)
+  cleanedContent = cleanedContent.replace(
+    /:\s*undefined\s*([,\}])/g,
+    ": null$1",
+  );
+
+  // 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;
+}
+
+/**
+ * Executes a prompt and returns the parsed JSON result
+ * @param messages - The messages to send
+ * @param context - The AI context
+ * @param options - Execution options
+ * @param requestOptions - Additional request options
+ * @param callback - Optional callback for streaming responses
+ * @param stream - Whether to stream the response
+ * @returns The parsed JSON object from the response content
+ * @throws Error if the response cannot be parsed or is not in the expected format
+ */
+export async function executePromptWithJsonResult<T = any>(
+  messages: Message[],
+  context:
+    | AiContext
+    | {
+        editContext: EditContextType;
+        createAiContext: ({ editContext }: { editContext: any }) => AiContext;
+      },
+  options: ExecutePromptOptions = {},
+  requestOptions?: RequestInit,
+  callback?: (parsedJson: T) => void,
+  stream?: boolean,
+): Promise<T> {
+  // Wrap the callback to parse JSON before passing to the original callback
+  const wrappedCallback = callback
+    ? (response: any) => {
+        if (!response || !response.content) {
+          return;
+        }
+
+        try {
+          const parsed = parseJsonContent<T>(response.content);
+          callback(parsed);
+        } catch (parseError) {
+          // During streaming, JSON may still be incomplete even after cleaning
+          // Only invoke callback when we have valid parseable JSON
+        }
+      }
+    : undefined;
+
+  const result = await executePrompt(
+    messages,
+    context,
+    options,
+    requestOptions,
+    wrappedCallback,
+    stream,
+  );
+
+  if (!result || !result.content) {
+    throw new Error("No content in response");
+  }
+
+  try {
+    return parseJsonContent<T>(result.content);
+  } catch (parseError) {
+    throw new Error(
+      `Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+    );
+  }
+}
+
 // moved to searchService.ts
 
 export async function generateImage(

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

@@ -21,7 +21,7 @@ import { convertPageSchemaToWizardComponents } from "./schema";
 import { WizardPageModel } from "../PageWizard";
 import { createWizardAiContext, wipeComponents } from "../service";
 
-import { executePrompt } 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";
@@ -152,7 +152,10 @@ export function ContentStep({
 
       console.log("PROMPT (selectTargetItem):", promptContent);
 
-      const result = await executePrompt(
+      const result = await executePromptWithJsonResult<{
+        id: string;
+        path: string;
+      }>(
         [
           {
             content: promptContent,
@@ -169,16 +172,11 @@ export function ContentStep({
         { signal: abortController.signal },
         (response) => {
           try {
-            const folderResult = JSON.parse(response.content) as {
-              id: string;
-              path: string;
-            };
-
-            if (folderResult.id && folderResult.path) {
-              setFolderSelectionResult(folderResult);
+            if (response.id && response.path) {
+              setFolderSelectionResult(response);
               // Update target folder with the selected folder
               setTargetFolder({
-                id: folderResult.id,
+                id: response.id,
                 language: language,
               } as ItemDescriptor);
             }
@@ -186,23 +184,13 @@ export function ContentStep({
         },
       );
 
-      if (result && result.messages && result.messages.length > 0) {
-        const lastMessage = result.messages[result.messages.length - 1];
-        if (lastMessage && lastMessage.content) {
-          const folderResult = JSON.parse(lastMessage.content) as {
-            id: string;
-            path: string;
-          };
-
-          if (folderResult.id && folderResult.path) {
-            setFolderSelectionResult(folderResult);
-            // Update target folder with the selected folder
-            setTargetFolder({
-              id: folderResult.id,
-              language: language,
-            } as ItemDescriptor);
-          }
-        }
+      if (result && result.id && result.path) {
+        setFolderSelectionResult(result);
+        // Update target folder with the selected folder
+        setTargetFolder({
+          id: result.id,
+          language: language,
+        } as ItemDescriptor);
       }
     } catch (error) {
       console.error("Error selecting target folder", error);
@@ -288,38 +276,30 @@ export function ContentStep({
 
       console.log("PROMPT (generatePageName):", promptContent);
 
-      const result = await executePrompt(
-        [
-          {
-            content: promptContent,
-            name: "system",
-            role: "system",
-            id: crypto.randomUUID(),
-          },
-        ],
-        { editContext, createAiContext: createWizardAiContext },
-        { model: step.fields.aiModel || undefined },
-        { signal: abortController.signal },
-        (response) => {
-          try {
-            const newLayout = JSON.parse(response.content) as WizardPageModel;
-            if (newLayout?.name) {
-              setPageModel((prev) => ({ ...prev, name: newLayout.name }));
-            }
-          } catch (parseError: unknown) {}
-        },
-      );
+      const pageModelResult =
+        await executePromptWithJsonResult<WizardPageModel>(
+          [
+            {
+              content: `${processedInstructions?.trim()} Reply with a json object of type PageModel = { name: string; };                       
+				  The language of the page is ${language}.`,
+              name: "system",
+              role: "system",
+              id: crypto.randomUUID(),
+            },
+            {
+              content: promptContent,
+              name: "user",
+              role: "user",
+              id: crypto.randomUUID(),
+            },
+          ],
+          { editContext, createAiContext: createWizardAiContext },
+          { model: step.fields.aiModel || undefined },
+          { signal: abortController.signal },
+        );
 
-      if (result && result.messages && result.messages.length > 0) {
-        const lastMessage = result.messages[result.messages.length - 1];
-        if (lastMessage && lastMessage.content) {
-          const pageModelResult = JSON.parse(
-            lastMessage.content,
-          ) as WizardPageModel;
-          if (pageModelResult?.name) {
-            setPageModel((prev) => ({ ...prev, name: pageModelResult.name }));
-          }
-        }
+      if (pageModelResult && pageModelResult.name) {
+        setPageModel((prev) => ({ ...prev, name: pageModelResult.name }));
       }
     } catch (error) {
       console.error("Error generating page name", error);
@@ -752,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");
@@ -838,7 +825,7 @@ export function ContentStep({
 
       console.log("PROMPT: ", prompt, filteredSchema, existingPageModel);
 
-      const result = await executePrompt(
+      const result = await executePromptWithJsonResult<WizardPageModel>(
         prompt,
         {
           editContext: editContextRef.current!,
@@ -850,33 +837,16 @@ export function ContentStep({
           endpoint: "/alpaca/editor/page-wizard/prompt",
         },
         { signal: localAbortController.signal },
-        (response: any) => {
+        (response: WizardPageModel) => {
           try {
-            // Handle streaming response - might have different structure during streaming
-            const content =
-              response.content ||
-              response.messages?.[response.messages.length - 1]?.content;
-            if (content) {
-              const newLayout = JSON.parse(content) as WizardPageModel;
-
-              if (newLayout) {
-                setPageModel((prev) => mergeLayout(prev, newLayout));
-              }
-
-              setMessage(newLayout.message);
-            }
+            setPageModel((prev) => mergeLayout(prev, response));
+            setMessage(response.message);
           } catch (parseError: unknown) {}
         },
       );
 
-      if (result && result.messages && result.messages.length > 0) {
-        const lastMessage = result.messages[result.messages.length - 1];
-        if (lastMessage && lastMessage.content) {
-          const finalLayout = JSON.parse(lastMessage.content);
-          console.log("RESULT LAYOUT: ", finalLayout);
-          setPageModel((prev) => mergeLayout(prev, finalLayout));
-        }
-      }
+      console.log("RESULT LAYOUT: ", result);
+      setPageModel((prev) => mergeLayout(prev, result));
       setStepCompleted(true);
     } catch (error) {
       console.error(error);

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

@@ -1,7 +1,7 @@
 import { useEffect, useState } from "react";
 import { FullItem } from "../../editor/pageModel";
 import { WizardPageModel } from "../PageWizard";
-import { executePrompt } from "../../editor/services/aiService";
+import { executePromptWithJsonResult } from "../../editor/services/aiService";
 import { createWizardAiContext } from "../service";
 import { useEditContext } from "../../editor/client/editContext";
 import { Textarea } from "../../components/ui/textarea";
@@ -24,7 +24,6 @@ export function MetaDataStep({
   setStepCompleted,
 }: StepComponentProps) {
   const [isGenerating, setIsGenerating] = useState(false);
-  const [fullParentItem, setFullParentItem] = useState<FullItem>();
   const editContext = useEditContext();
 
   useEffect(() => {
@@ -35,15 +34,6 @@ export function MetaDataStep({
     }
   }, [editContext]);
 
-  useEffect(() => {
-    const loadParentItem = async () => {
-      if (!parentItem) return;
-      const item = await editContext?.itemsRepository.getItem(parentItem);
-      setFullParentItem(item);
-    };
-    loadParentItem();
-  }, [parentItem]);
-
   // Mark step as completed immediately since this is now just informational
   useEffect(() => {
     setStepCompleted(true);
@@ -87,56 +77,58 @@ export function MetaDataStep({
     try {
       const abortController = new AbortController();
 
-      const result = await executePrompt(
-        [
-          {
-            content: `${processedSystemInstructions}\nYou are a helpful assistant that generates SEO metadata for a page.\n\nReturn ONLY valid JSON in this exact shape: {"metaDescription": string, "metaKeywords": string}.\nLanguage: ${parentItem?.language || "en"}.`,
-            name: "system",
-            role: "system",
-            id: crypto.randomUUID(),
-          },
-          {
-            content: `${processedInstructions}\n\nCurrent data: ${JSON.stringify(
-              inputData,
-              null,
-              2,
-            )}`,
-            name: "user",
-            role: "user",
-            id: crypto.randomUUID(),
-          },
-        ],
-        { editContext, createAiContext: createWizardAiContext },
-        { model: step.fields.aiModel || undefined },
-        { signal: abortController.signal },
-        (response: any) => {
-          try {
-            const newLayout = JSON.parse(response.content) as WizardPageModel;
-            if (newLayout && setPageModel) {
-              setPageModel((prev) => ({
-                ...prev,
-                metaDescription:
-                  (newLayout as any)?.metaDescription ?? prev.metaDescription,
-                metaKeywords:
-                  (newLayout as any)?.metaKeywords ?? prev.metaKeywords,
-              }));
+      const pageModelResult =
+        await executePromptWithJsonResult<WizardPageModel>(
+          [
+            {
+              content: `${processedSystemInstructions}\nYou are a helpful assistant that generates SEO metadata for a page.\n\nReturn ONLY valid JSON in this exact shape: {"metaDescription": string, "metaKeywords": string}.\nLanguage: ${parentItem?.language || "en"}.`,
+              name: "system",
+              role: "system",
+              id: crypto.randomUUID(),
+            },
+            {
+              content: `${processedInstructions}\n\nCurrent data: ${JSON.stringify(
+                inputData,
+                null,
+                2,
+              )}`,
+              name: "user",
+              role: "user",
+              id: crypto.randomUUID(),
+            },
+          ],
+          { editContext, createAiContext: createWizardAiContext },
+          { model: step.fields.aiModel || undefined },
+          { signal: abortController.signal },
+          (response: any) => {
+            try {
+              const newLayout = JSON.parse(response.content) as WizardPageModel;
+              if (newLayout && setPageModel) {
+                setPageModel((prev) => ({
+                  ...prev,
+                  metaDescription:
+                    (newLayout as any)?.metaDescription ?? prev.metaDescription,
+                  metaKeywords:
+                    (newLayout as any)?.metaKeywords ?? prev.metaKeywords,
+                }));
+              }
+            } catch {
+              // Ignore parsing errors during streaming
             }
-          } catch {}
-        },
-      );
-
-      if (result && result.messages && result.messages.length > 0) {
-        const lastMessage = result.messages[result.messages.length - 1];
-        if (lastMessage && lastMessage.content) {
-          const pageModelResult = JSON.parse(
-            lastMessage.content,
-          ) as WizardPageModel;
-          setPageModel((prev) => ({
-            ...prev,
-            metaDescription: pageModelResult.metaDescription,
-            metaKeywords: pageModelResult.metaKeywords,
-          }));
-        }
+          },
+        );
+
+      // Parse the final result
+      if (
+        pageModelResult &&
+        pageModelResult.metaDescription &&
+        pageModelResult.metaKeywords
+      ) {
+        setPageModel((prev) => ({
+          ...prev,
+          metaDescription: pageModelResult.metaDescription,
+          metaKeywords: pageModelResult.metaKeywords,
+        }));
       }
     } catch (error) {
       console.error("Error generating meta fields", error);