@alpaca-editor/core 1.0.4135 → 1.0.4141

package/src/editor/services/agentService.ts

@@ -7,19 +7,11 @@ export interface StartAgentRequest {
   agentId: string;
   message: string;
   sessionId: string;
-  profileId: string;
-  // Execution mode: 'agent' enables all tools as per profile; 'ask' restricts to askModeTools
-  mode?: "agent" | "ask" | "restricted";
+  profileId: string; // GUID of the AI profile
+  // Execution mode: 'autonomous' enables all tools as per profile; 'read-only' restricts to askModeTools; 'supervised' requires approval for actions outside current context
+  mode?: "autonomous" | "read-only" | "supervised";
   model?: string;
-  itemid: string;
-  language: string;
-  version: number;
-  selection?: string[];
-  selectedText?: string;
-  allowedFunctions?: string[];
-  addContextContent?: boolean;
-  addAllContent?: boolean;
-  addSelectedComponents?: boolean;
+  /** @deprecated Use profileId instead. Kept for backward compatibility. */
   profile?: string;
   deterministic?: boolean;
   seed?: number;
@@ -48,9 +40,19 @@ export type AgentStreamMessageType =
   | "toolResult"
   | "editOperations"
   | "completed"
-  | "error";
-
-export type AgentStatus = "new" | "running" | "closed" | "cancelled";
+  | "error"
+  | "contextUpdate";
+
+export type AgentStatus =
+  | "new"
+  | "running"
+  | "waitingForApproval"
+  | "closed"
+  | "cancelled"
+  | "completed"
+  | "error"
+  | "idle"
+  | number;
 
 export type Agent = {
   id: string;
@@ -61,10 +63,6 @@ export type Agent = {
 };
 
 export type AgentDetails = Agent & {
-  itemId: string;
-  itemPath: string;
-  language: string;
-  version: number;
   profileId?: string;
   profileName: string;
   model: string;
@@ -82,7 +80,10 @@ export type AgentDetails = Agent & {
   totalCost: number;
   currency: string;
   messageCount: number;
-  metadata?: string;
+  /** Cost limit for this agent (in USD) */
+  costLimit?: number;
+  /** Agent context data (JSON string) - contains pages, componentIds, field, comment, etc. */
+  agentContext?: string;
   messages?: AgentChatMessage[];
 };
 
@@ -126,44 +127,55 @@ export async function rejectToolCall(params: {
   return result.data ?? { success: true };
 }
 
-// Metadata shape stored on the agent. Server accepts a flexible JSON object; keep it permissive.
-export type AgentMetadata = {
+// Simplified context data for agent chats - matches AgentContextData on server
+export type AgentContextData = {
   selection?: string[];
   selectedText?: string;
-  allowedFunctions?: string[];
-  mode?: "agent" | "ask" | "restricted";
-  addContextContent?: boolean;
-  addAllContent?: boolean;
-  addSelectedComponents?: boolean;
-  profile?: string;
-  additionalData?: Record<string, any>;
-  context?: {
-    pages?: Array<{
+  pages?: Array<{
+    id: string;
+    language: string;
+    version: number;
+    path?: string;
+    name?: string;
+  }>;
+  /** Component context with page information per component */
+  components?: Array<{
+    componentId: string;
+    pageItem: {
       id: string;
       language: string;
       version: number;
       path?: string;
       name?: string;
-    }>;
-    componentIds?: string[];
-    field?: {
-      fieldId: string;
-      itemId: string;
-      name?: string;
-    };
-    comment?: {
-      id: string;
-      text?: string;
-      fieldName?: string;
-      itemName?: string;
-      author?: string;
-      selectedText?: string;
-      rangeStart?: number;
-      rangeEnd?: number;
     };
+  }>;
+  /** @deprecated Use components instead to get page information per component */
+  componentIds?: string[];
+  field?: {
+    fieldId: string;
+    itemId: string;
+    name?: string;
   };
+  comment?: {
+    id: string;
+    text?: string;
+    fieldName?: string;
+    itemName?: string;
+    author?: string;
+    selectedText?: string;
+    rangeStart?: number;
+    rangeEnd?: number;
+  };
+  mode?: "autonomous" | "read-only" | "supervised";
+  profile?: string;
+  costLimit?: number;
+  initialCostLimit?: number;
+  additionalData?: Record<string, any>;
 };
 
+// Legacy alias for backward compatibility
+export type AgentMetadata = AgentContextData;
+
 export interface AgentChatMessage {
   id: string;
   agentId: string;
@@ -359,6 +371,9 @@ async function processEventStream(
                   case 6:
                     message.type = "error";
                     break;
+                  case 7:
+                    message.type = "contextUpdate";
+                    break;
                   default:
                     message.type = `Unknown_${message.type}`;
                 }
@@ -484,6 +499,28 @@ export async function getClosedAgents(limit?: number): Promise<Agent[]> {
   return result.data || [];
 }
 
+/**
+ * Gets all non-closed agents across all users (admin only)
+ */
+export async function getAllAgents(limit?: number): Promise<AgentDetails[]> {
+  const params = new URLSearchParams();
+  if (limit) params.append("limit", limit.toString());
+
+  const queryString = params.toString();
+  const url =
+    AGENT_BASE_URL + "/getAllAgents" + (queryString ? `?${queryString}` : "");
+
+  const result = await get<AgentDetails[]>(url);
+
+  if (result.type !== "success") {
+    throw new Error(
+      `Failed to get all agents: ${result.summary || "Unknown error"} ${result.details || ""}`,
+    );
+  }
+
+  return result.data || [];
+}
+
 /**
  * Cancels a running agent execution
  */
@@ -541,7 +578,7 @@ export async function updateAgentSettings(
   agentId: string,
   settings: {
     model?: string | null;
-    mode?: "agent" | "ask" | "restricted" | string | null;
+    mode?: "autonomous" | "read-only" | "supervised" | string | null;
   },
 ): Promise<{ success: boolean; updates?: { model: boolean; mode: boolean } }> {
   const result = await post<{
@@ -565,7 +602,7 @@ export async function updateAgentSettings(
 /**
  * Updates the metadata (context) for an agent chat
  */
-export async function updateAgentMetadata(
+export async function updateAgentContext(
   agentId: string,
   metadata: AgentMetadata,
 ): Promise<{ success: boolean }> {
@@ -575,8 +612,8 @@ export async function updateAgentMetadata(
   const { context: _drop, ...cleanNoTop } = clean as any;
 
   const result = await post<{ success: boolean }>(
-    AGENT_BASE_URL + "/updateMetadata",
-    { agentId, metadata: cleanNoTop },
+    AGENT_BASE_URL + "/updateContext",
+    { agentId, ...cleanNoTop },
   );
 
   if (result.type !== "success") {
@@ -590,13 +627,18 @@ export async function updateAgentMetadata(
 
 export async function updateAgentCostLimit(
   agentId: string,
-  action: "extend" | "remove" | "set",
+  action: "extend" | "set",
   amount?: number,
-): Promise<{ success: boolean; metadata?: any }> {
-  const result = await post<{ success: boolean; metadata?: any }>(
-    AGENT_BASE_URL + "/updateCostLimit",
-    { agentId, action, amount },
-  );
+): Promise<{
+  success: boolean;
+  costLimit?: number;
+  initialCostLimit?: number;
+}> {
+  const result = await post<{
+    success: boolean;
+    costLimit?: number;
+    initialCostLimit?: number;
+  }>(AGENT_BASE_URL + "/updateCostLimit", { agentId, action, amount });
 
   if (result.type !== "success") {
     throw new Error(
@@ -704,19 +746,13 @@ export function convertAgentMessagesToTerminalFormat(
 }
 
 // Canonicalize metadata to a stable, collision-free shape for both client use and POST payloads
-export function canonicalizeAgentMetadata(meta: AgentMetadata | any): AgentMetadata {
+export function canonicalizeAgentMetadata(
+  meta: AgentMetadata | any,
+): AgentContextData {
   const m: any = { ...(meta || {}) };
-  // Drop accidental top-level context copies
-  if (Object.prototype.hasOwnProperty.call(m, "context")) {
-    delete m.context;
-  }
 
   // Normalize known PascalCase top-level metadata keys to camelCase
-  const normalizeTop = (
-    source: any,
-    from: string,
-    to: string,
-  ) => {
+  const normalizeTop = (source: any, from: string, to: string) => {
     if (Object.prototype.hasOwnProperty.call(source, from)) {
       if (!Object.prototype.hasOwnProperty.call(source, to)) {
         source[to] = source[from];
@@ -726,47 +762,50 @@ export function canonicalizeAgentMetadata(meta: AgentMetadata | any): AgentMetad
   };
   normalizeTop(m, "Selection", "selection");
   normalizeTop(m, "SelectedText", "selectedText");
-  normalizeTop(m, "AllowedFunctions", "allowedFunctions");
   normalizeTop(m, "Mode", "mode");
-  normalizeTop(m, "AddContextContent", "addContextContent");
-  normalizeTop(m, "AddAllContent", "addAllContent");
-  normalizeTop(m, "AddSelectedComponents", "addSelectedComponents");
   normalizeTop(m, "Profile", "profile");
   normalizeTop(m, "CostLimit", "costLimit");
   normalizeTop(m, "InitialCostLimit", "initialCostLimit");
-  normalizeTop(m, "CostLimitDisabled", "costLimitDisabled");
+  normalizeTop(m, "Pages", "pages");
+  normalizeTop(m, "ComponentIds", "componentIds");
+  normalizeTop(m, "Field", "field");
+  normalizeTop(m, "Comment", "comment");
+
+  // Handle legacy context nested structure - lift to top level
+  const contextSources: any[] = [];
+  if (m.context && typeof m.context === "object") {
+    contextSources.push(m.context);
+    delete m.context;
+  }
 
-  // Merge both additionalData and AdditionalData (case variants)
-  const sources: any[] = [];
-  if (m.additionalData && typeof m.additionalData === "object") sources.push(m.additionalData);
-  if (m.AdditionalData && typeof m.AdditionalData === "object") sources.push(m.AdditionalData);
-  const additional: any = {};
-  for (const src of sources) {
-    for (const k of Object.keys(src)) {
-      // Shallow merge; context handled below
-      if (k.toLowerCase() !== "context") {
-        if (additional[k] === undefined) additional[k] = src[k];
-      }
-    }
+  // Merge additionalData context entries
+  const additionalDataSources: any[] = [];
+  if (m.additionalData && typeof m.additionalData === "object") {
+    additionalDataSources.push(m.additionalData);
+  }
+  if (m.AdditionalData && typeof m.AdditionalData === "object") {
+    additionalDataSources.push(m.AdditionalData);
   }
 
-  // Merge any case-variant "context" entries into one canonical object
-  const contextCandidates: any[] = [];
-  for (const src of sources) {
+  for (const src of additionalDataSources) {
     for (const key of Object.keys(src)) {
-      if (key.toLowerCase() === "context") {
-        if (src[key] != null) contextCandidates.push(src[key]);
+      if (key.toLowerCase() === "context" && src[key]) {
+        contextSources.push(src[key]);
       }
     }
   }
 
-  const ctx: any = {};
-  const pushPages = (arr: any[]) => {
-    const existing: any[] = Array.isArray(ctx.pages) ? ctx.pages : [];
-    const combined = [...existing, ...arr];
+  // Process pages
+  const allPages: any[] = [];
+  if (Array.isArray(m.pages)) allPages.push(...m.pages);
+  for (const ctx of contextSources) {
+    if (Array.isArray(ctx.pages)) allPages.push(...ctx.pages);
+    if (Array.isArray(ctx.items)) allPages.push(...ctx.items); // legacy
+  }
+  if (allPages.length > 0) {
     const dedup: any[] = [];
     const seen = new Set<string>();
-    for (const p of combined) {
+    for (const p of allPages) {
       const id = p?.id ?? p?.Id;
       if (!id) continue;
       const lang = (p?.language ?? p?.Language ?? "").toString();
@@ -782,52 +821,101 @@ export function canonicalizeAgentMetadata(meta: AgentMetadata | any): AgentMetad
         path: p?.path ?? p?.Path,
       });
     }
-    if (dedup.length) ctx.pages = dedup;
-  };
-  const pushComponentIds = (ids: any[]) => {
-    const existing: string[] = Array.isArray(ctx.componentIds) ? ctx.componentIds : [];
-    const all = [...existing, ...ids]
-      .map((x) => (typeof x === "string" ? x : x?.id ?? x?.Id))
+    m.pages = dedup;
+  }
+
+  // Process components with page info (new structure)
+  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;
+      if (!componentId || typeof componentId !== "string") continue;
+      const key = componentId.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      const pageItem = c.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,
+            }
+          : undefined,
+      });
+    }
+    m.components = dedup;
+  }
+
+  // Process componentIds (legacy - for backward compatibility)
+  const allComponentIds: any[] = [];
+  if (Array.isArray(m.componentIds)) allComponentIds.push(...m.componentIds);
+  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");
-    if (all.length) ctx.componentIds = Array.from(new Set(all));
-  };
+    m.componentIds = Array.from(new Set(ids));
+  }
 
-  for (const candidate of contextCandidates) {
-    if (!candidate || typeof candidate !== "object") continue;
-    for (const k of Object.keys(candidate)) {
-      const lk = k.toLowerCase();
-      const val = (candidate as any)[k];
-      if (lk === "pages" && Array.isArray(val)) {
-        pushPages(val);
-      } else if (lk === "items" && Array.isArray(val)) {
-        // Support legacy key
-        pushPages(val);
-      } else if (lk === "componentids" && Array.isArray(val)) {
-        pushComponentIds(val);
-      } else if (lk === "components" && Array.isArray(val)) {
-        pushComponentIds(val);
-      } else if (lk === "field" && !ctx.field && val) {
-        ctx.field = {
-          fieldId: val.fieldId ?? val.FieldId ?? val.id ?? val.Id,
-          itemId: val.itemId ?? val.ItemId,
-          name: val.name ?? val.Name,
+  // Process field
+  if (!m.field) {
+    for (const ctx of contextSources) {
+      if (ctx.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,
         };
-      } else if (lk === "comment" && !ctx.comment && val) {
-        ctx.comment = val;
-      } else if (lk === "todolist" && !ctx.todoList && val) {
-        ctx.todoList = val;
+        break;
       }
     }
   }
 
-  if (Object.keys(ctx).length > 0) {
-    additional.context = ctx;
+  // Process comment
+  if (!m.comment) {
+    for (const ctx of contextSources) {
+      if (ctx.comment) {
+        m.comment = ctx.comment;
+        break;
+      }
+    }
+  }
+
+  // Merge additionalData (excluding context which we've lifted)
+  const additional: any = {};
+  for (const src of additionalDataSources) {
+    for (const k of Object.keys(src)) {
+      if (k.toLowerCase() !== "context") {
+        if (additional[k] === undefined) additional[k] = src[k];
+      }
+    }
   }
 
-  // Assign canonical, remove other case variants
   m.additionalData = Object.keys(additional).length ? additional : undefined;
   if (Object.prototype.hasOwnProperty.call(m, "AdditionalData")) {
     delete m.AdditionalData;
   }
-  return m as AgentMetadata;
+
+  return m as AgentContextData;
 }

package/src/editor/services/aiService.ts

@@ -23,8 +23,8 @@ export type AiProfile = {
   includeEditorContextOnCreate?: boolean;
   // When true, the agent should run in managed TODO list mode.
   managedTodoMode?: boolean;
-  // Tools that are allowed when the user switches to "Ask" mode
-  askModeTools?: string[];
+  // Tools that are allowed when the user switches to "Read-Only" mode
+  readOnlyModeTools?: string[];
   // Optional cost limit in USD, sourced from profile
   costLimit?: number | null;
 };

package/src/editor/services/editService.ts

@@ -133,6 +133,7 @@ export async function lockField(
   fieldId: string,
   sessionId: string,
 ): Promise<ExecutionResult<any>> {
+  console.trace("[editService] locking field:", fieldId, "for item:", item.id);
   const response = await post("/alpaca/editor/lockField", {
     item,
     fieldId: fieldId,