@mydatavalue/polter 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { createContext, useRef, useState, useCallback, useMemo, useContext, useEffect, useId } from 'react';
+import { createContext, useRef, useState, useEffect, useCallback, useMemo, useContext, useId } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 // src/components/AgentActionProvider.tsx
@@ -435,6 +435,20 @@ async function executeAction(action, params, config) {
   return executeGuided(action, params, config);
 }
 var AgentActionContext = createContext(null);
+function definitionToRegisteredAction(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    parameters: def.parameters,
+    onExecute: def.onExecute,
+    disabled: false,
+    disabledReason: void 0,
+    getExecutionTargets: () => [],
+    route: def.route,
+    navigateVia: def.navigateVia,
+    mountTimeout: def.mountTimeout
+  };
+}
 function AgentActionProvider({
   mode = "guided",
   stepDelay = 600,
@@ -444,24 +458,61 @@ function AgentActionProvider({
   cursorEnabled = true,
   children,
   onExecutionStart,
-  onExecutionComplete
+  onExecutionComplete,
+  registry,
+  navigate
 }) {
   const actionsRef = useRef(/* @__PURE__ */ new Map());
   const targetsRef = useRef(/* @__PURE__ */ new Map());
+  const registryRef = useRef(/* @__PURE__ */ new Map());
+  const navigateRef = useRef(navigate);
+  navigateRef.current = navigate;
   const [version, setVersion] = useState(0);
   const [isExecuting, setIsExecuting] = useState(false);
   const currentExecutionRef = useRef(null);
+  useEffect(() => {
+    const newNames = /* @__PURE__ */ new Set();
+    for (const def of registry ?? []) {
+      newNames.add(def.name);
+      const registryAction = definitionToRegisteredAction(def);
+      registryRef.current.set(def.name, registryAction);
+      const existing = actionsRef.current.get(def.name);
+      if (!existing || existing.getExecutionTargets().length === 0) {
+        actionsRef.current.set(def.name, registryAction);
+      }
+    }
+    for (const name of registryRef.current.keys()) {
+      if (!newNames.has(name)) {
+        registryRef.current.delete(name);
+        const current = actionsRef.current.get(name);
+        if (current && current.getExecutionTargets().length === 0) {
+          actionsRef.current.delete(name);
+        }
+      }
+    }
+    setVersion((v) => v + 1);
+  }, [registry]);
   const registerAction = useCallback((action) => {
     const existing = actionsRef.current.get(action.name);
+    const registryAction = registryRef.current.get(action.name);
+    if (registryAction) {
+      if (!action.route) action.route = registryAction.route;
+      if (!action.navigateVia) action.navigateVia = registryAction.navigateVia;
+      if (action.mountTimeout == null) action.mountTimeout = registryAction.mountTimeout;
+    }
     actionsRef.current.set(action.name, action);
     if (!existing || existing.description !== action.description || existing.disabled !== action.disabled || existing.disabledReason !== action.disabledReason) {
       setVersion((v) => v + 1);
     }
   }, []);
   const unregisterAction = useCallback((name) => {
-    if (actionsRef.current.delete(name)) {
-      setVersion((v) => v + 1);
+    const registryAction = registryRef.current.get(name);
+    if (registryAction) {
+      actionsRef.current.set(name, registryAction);
+    } else {
+      actionsRef.current.delete(name);
     }
+    setVersion((v) => v + 1);
   }, []);
   const registerTarget = useCallback((id, entry) => {
     targetsRef.current.set(id, entry);
@@ -506,12 +557,29 @@ function AgentActionProvider({
     },
     []
   );
+  const waitForActionMount = useCallback(
+    async (name, signal, timeout = 5e3) => {
+      const maxWait = timeout;
+      const pollInterval = 50;
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        if (signal?.aborted) return null;
+        const current = actionsRef.current.get(name);
+        if (current && (current.componentBacked || current.getExecutionTargets().length > 0)) {
+          return current;
+        }
+        await new Promise((r) => setTimeout(r, pollInterval));
+      }
+      return actionsRef.current.get(name) ?? null;
+    },
+    []
+  );
   const execute = useCallback(
     async (actionName, params) => {
       currentExecutionRef.current?.abort();
       const controller = new AbortController();
       currentExecutionRef.current = controller;
-      const action = actionsRef.current.get(actionName);
+      let action = actionsRef.current.get(actionName);
       if (!action) {
         return { success: false, actionName, error: `Action "${actionName}" not found` };
       }
@@ -525,7 +593,7 @@ function AgentActionProvider({
       setIsExecuting(true);
       onExecutionStart?.(actionName);
       try {
-        const result = await executeAction(action, params ?? {}, {
+        const executorConfig = {
           mode,
           stepDelay,
           overlayOpacity,
@@ -535,7 +603,68 @@ function AgentActionProvider({
           signal: controller.signal,
           resolveTarget,
           resolveNamedTarget
-        });
+        };
+        const schema = action.parameters;
+        if (schema?.safeParse) {
+          const validation = schema.safeParse(params ?? {});
+          if (!validation.success) {
+            const missing = validation.error.issues.map((i) => i.path.join(".")).filter(Boolean);
+            const error = missing.length > 0 ? `Required parameters missing: ${missing.join(", ")}` : validation.error.issues.map((i) => i.message).join("; ");
+            return { success: false, actionName, error };
+          }
+        }
+        if (action.navigateVia && action.navigateVia.length > 0) {
+          for (const viaName of action.navigateVia) {
+            if (controller.signal.aborted) break;
+            const viaRegistered = actionsRef.current.get(viaName);
+            const viaTimeout = viaRegistered?.mountTimeout ?? 1e4;
+            const viaAction = await waitForActionMount(viaName, controller.signal, viaTimeout);
+            if (!viaAction || viaAction.getExecutionTargets().length === 0) {
+              return {
+                success: false,
+                actionName,
+                error: `Navigation chain action "${viaName}" not found or has no targets`
+              };
+            }
+            const viaResult = await executeAction(viaAction, {}, executorConfig);
+            if (!viaResult.success) {
+              return {
+                success: false,
+                actionName,
+                error: `Navigation chain failed at "${viaName}": ${viaResult.error}`
+              };
+            }
+          }
+          const mounted = await waitForActionMount(actionName, controller.signal, action.mountTimeout ?? 1e4);
+          if (!mounted || !mounted.componentBacked) {
+            return {
+              success: false,
+              actionName,
+              error: `Action "${actionName}" did not mount after navigation chain \u2014 the page may require authentication or failed to load`
+            };
+          }
+          action = mounted;
+        } else {
+          const targets = action.getExecutionTargets();
+          if (targets.length === 0 && action.route && navigateRef.current) {
+            const path = action.route(params ?? {});
+            await navigateRef.current(path);
+            const mounted = await waitForActionMount(actionName, controller.signal, action.mountTimeout);
+            if (mounted) {
+              action = mounted;
+            }
+          }
+        }
+        if (action.disabled) {
+          const result2 = {
+            success: false,
+            actionName,
+            error: action.disabledReason || "Action is disabled"
+          };
+          onExecutionComplete?.(result2);
+          return result2;
+        }
+        const result = await executeAction(action, params ?? {}, executorConfig);
         onExecutionComplete?.(result);
         return result;
       } catch (err) {
@@ -553,7 +682,7 @@ function AgentActionProvider({
         }
       }
     },
-    [mode, stepDelay, overlayOpacity, spotlightPadding, tooltipEnabled, cursorEnabled, onExecutionStart, onExecutionComplete, resolveTarget, resolveNamedTarget]
+    [mode, stepDelay, overlayOpacity, spotlightPadding, tooltipEnabled, cursorEnabled, onExecutionStart, onExecutionComplete, resolveTarget, resolveNamedTarget, waitForActionMount]
   );
   const availableActions = useMemo(
     () => Array.from(actionsRef.current.values()).map((a) => ({
@@ -598,19 +727,24 @@ function AgentActionProvider({
   return /* @__PURE__ */ jsx(AgentActionContext.Provider, { value: contextValue, children });
 }
 var AgentStepContext = createContext(null);
-function AgentAction({
-  name,
-  description,
-  parameters,
-  onExecute,
-  disabled = false,
-  disabledReason,
-  children
-}) {
+function AgentAction(props) {
+  const {
+    action,
+    onExecute,
+    disabled = false,
+    disabledReason,
+    children
+  } = props;
+  const name = props.name ?? action?.name;
+  const description = props.description ?? action?.description ?? "";
+  const parameters = props.parameters ?? action?.parameters;
   const context = useContext(AgentActionContext);
   if (!context) {
     throw new Error("AgentAction must be used within an AgentActionProvider");
   }
+  if (!name) {
+    throw new Error('AgentAction requires either a "name" prop or an "action" prop');
+  }
   const wrapperRef = useRef(null);
   const stepsRef = useRef(/* @__PURE__ */ new Map());
   const onExecuteRef = useRef(onExecute);
@@ -654,7 +788,8 @@ function AgentAction({
       onExecute: onExecuteRef.current ? stableOnExecute : void 0,
       disabled,
       disabledReason,
-      getExecutionTargets
+      getExecutionTargets,
+      componentBacked: true
     });
     return () => unregisterAction(name);
   }, [name, description, disabled, disabledReason, stableOnExecute, getExecutionTargets, registerAction, unregisterAction]);
@@ -1249,15 +1384,28 @@ function useAgentCommandRouter(fallback, getActionName) {
       const actionName = getActionName(command);
       const isRegistered = availableActions.some((a) => a.name === actionName && !a.disabled);
       if (isRegistered) {
-        await execute(actionName, command);
-        return;
+        return await execute(actionName, command);
       }
       await fallback?.(command);
+      return void 0;
     },
     [execute, availableActions, fallback, getActionName]
   );
 }
 
-export { AgentAction, AgentActionProvider, AgentDevTools, AgentStep, AgentTarget, generateToolSchemas, useAgentAction, useAgentActions, useAgentCommandRouter, zodToJsonSchema };
+// src/core/defineAction.ts
+function defineAction(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    route: config.route,
+    onExecute: config.onExecute,
+    navigateVia: config.navigateVia,
+    mountTimeout: config.mountTimeout
+  };
+}
+
+export { AgentAction, AgentActionProvider, AgentDevTools, AgentStep, AgentTarget, defineAction, generateToolSchemas, useAgentAction, useAgentActions, useAgentCommandRouter, zodToJsonSchema };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map