vanilla-agent 1.5.0 → 1.6.0

package/src/utils/actions.ts

@@ -0,0 +1,228 @@
+import type {
+  AgentWidgetActionContext,
+  AgentWidgetActionEventPayload,
+  AgentWidgetActionHandler,
+  AgentWidgetActionHandlerResult,
+  AgentWidgetActionParser,
+  AgentWidgetParsedAction,
+  AgentWidgetControllerEventMap,
+  AgentWidgetMessage
+} from "../types";
+
+type ActionManagerProcessContext = {
+  text: string;
+  message: AgentWidgetMessage;
+  streaming: boolean;
+  raw?: string;
+};
+
+type ActionManagerOptions = {
+  parsers: AgentWidgetActionParser[];
+  handlers: AgentWidgetActionHandler[];
+  getMetadata: () => Record<string, unknown>;
+  updateMetadata: (
+    updater: (prev: Record<string, unknown>) => Record<string, unknown>
+  ) => void;
+  emit: <K extends keyof AgentWidgetControllerEventMap>(
+    event: K,
+    payload: AgentWidgetControllerEventMap[K]
+  ) => void;
+  documentRef: Document | null;
+};
+
+const stripCodeFence = (value: string) => {
+  const match = value.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  return match ? match[1] : value;
+};
+
+const extractJsonObject = (value: string) => {
+  const trimmed = value.trim();
+  const start = trimmed.indexOf("{");
+  if (start === -1) return null;
+
+  let depth = 0;
+  for (let i = start; i < trimmed.length; i += 1) {
+    const char = trimmed[i];
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return trimmed.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+};
+
+export const defaultJsonActionParser: AgentWidgetActionParser = ({ text }) => {
+  if (!text) return null;
+  if (!text.includes("{")) return null;
+
+  try {
+    const withoutFence = stripCodeFence(text);
+    const jsonBody = extractJsonObject(withoutFence);
+    if (!jsonBody) return null;
+    const parsed = JSON.parse(jsonBody);
+    if (!parsed || typeof parsed !== "object" || !parsed.action) {
+      return null;
+    }
+    const { action, ...payload } = parsed;
+    return {
+      type: String(action),
+      payload,
+      raw: parsed
+    };
+  } catch {
+    return null;
+  }
+};
+
+const asString = (value: unknown) =>
+  typeof value === "string" ? value : value == null ? "" : String(value);
+
+export const defaultActionHandlers: Record<
+  string,
+  AgentWidgetActionHandler
+> = {
+  message: (action) => {
+    if (action.type !== "message") return;
+    const text = asString((action.payload as Record<string, unknown>).text);
+    return {
+      handled: true,
+      displayText: text
+    };
+  },
+  messageAndClick: (action, context) => {
+    if (action.type !== "message_and_click") return;
+    const payload = action.payload as Record<string, unknown>;
+    const selector = asString(payload.element);
+    if (selector && context.document?.querySelector) {
+      const element = context.document.querySelector<HTMLElement>(selector);
+      if (element) {
+        setTimeout(() => {
+          element.click();
+        }, 400);
+      } else if (typeof console !== "undefined") {
+        // eslint-disable-next-line no-console
+        console.warn("[AgentWidget] Element not found for selector:", selector);
+      }
+    }
+    return {
+      handled: true,
+      displayText: asString(payload.text)
+    };
+  }
+};
+
+const ensureArrayOfStrings = (value: unknown): string[] => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry));
+  }
+  return [];
+};
+
+export const createActionManager = (options: ActionManagerOptions) => {
+  let processedIds = new Set(
+    ensureArrayOfStrings(options.getMetadata().processedActionMessageIds)
+  );
+
+  const syncFromMetadata = () => {
+    processedIds = new Set(
+      ensureArrayOfStrings(options.getMetadata().processedActionMessageIds)
+    );
+  };
+
+  const persistProcessedIds = () => {
+    const latestIds = Array.from(processedIds);
+    options.updateMetadata((prev) => ({
+      ...prev,
+      processedActionMessageIds: latestIds
+    }));
+  };
+
+  const process = (context: ActionManagerProcessContext): string | null => {
+    if (
+      context.streaming ||
+      context.message.role !== "assistant" ||
+      !context.text ||
+      processedIds.has(context.message.id)
+    ) {
+      return null;
+    }
+
+    const parseSource =
+      (typeof context.raw === "string" && context.raw) ||
+      (typeof context.message.rawContent === "string" &&
+        context.message.rawContent) ||
+      (typeof context.text === "string" && context.text) ||
+      null;
+
+    if (
+      !parseSource &&
+      typeof context.text === "string" &&
+      context.text.trim().startsWith("{") &&
+      typeof console !== "undefined"
+    ) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        "[AgentWidget] Structured response detected but no raw payload was provided. Ensure your stream parser returns { text, raw }."
+      );
+    }
+
+    const action = parseSource
+      ? options.parsers.reduce<AgentWidgetParsedAction | null>(
+          (acc, parser) =>
+            acc || parser?.({ text: parseSource, message: context.message }) || null,
+          null
+        )
+      : null;
+
+    if (!action) {
+      return null;
+    }
+
+    processedIds.add(context.message.id);
+    persistProcessedIds();
+
+    const eventPayload: AgentWidgetActionEventPayload = {
+      action,
+      message: context.message
+    };
+    options.emit("action:detected", eventPayload);
+
+    for (const handler of options.handlers) {
+      if (!handler) continue;
+      try {
+        const handlerResult = handler(action, {
+          message: context.message,
+          metadata: options.getMetadata(),
+          updateMetadata: options.updateMetadata,
+          document: options.documentRef
+        } as AgentWidgetActionContext) as AgentWidgetActionHandlerResult | void;
+
+        if (!handlerResult) continue;
+
+        if (handlerResult.displayText !== undefined && handlerResult.handled) {
+          return handlerResult.displayText;
+        }
+
+        if (handlerResult.handled) {
+          return "";
+        }
+      } catch (error) {
+        if (typeof console !== "undefined") {
+          // eslint-disable-next-line no-console
+          console.error("[AgentWidget] Action handler error:", error);
+        }
+      }
+    }
+
+    return "";
+  };
+
+  return {
+    process,
+    syncFromMetadata
+  };
+};
+

package/src/utils/events.ts

@@ -0,0 +1,41 @@
+type Handler<T> = (payload: T) => void;
+
+export type EventUnsubscribe = () => void;
+
+export const createEventBus = <EventMap extends Record<string, any>>() => {
+  const listeners = new Map<keyof EventMap, Set<Handler<any>>>();
+
+  const on = <K extends keyof EventMap>(
+    event: K,
+    handler: Handler<EventMap[K]>
+  ): EventUnsubscribe => {
+    if (!listeners.has(event)) {
+      listeners.set(event, new Set());
+    }
+    listeners.get(event)!.add(handler as Handler<any>);
+    return () => off(event, handler);
+  };
+
+  const off = <K extends keyof EventMap>(
+    event: K,
+    handler: Handler<EventMap[K]>
+  ) => {
+    listeners.get(event)?.delete(handler as Handler<any>);
+  };
+
+  const emit = <K extends keyof EventMap>(event: K, payload: EventMap[K]) => {
+    listeners.get(event)?.forEach((handler) => {
+      try {
+        handler(payload);
+      } catch (error) {
+        if (typeof console !== "undefined") {
+          // eslint-disable-next-line no-console
+          console.error("[AgentWidget] Event handler error:", error);
+        }
+      }
+    });
+  };
+
+  return { on, off, emit };
+};
+

package/src/utils/formatting.ts

@@ -140,7 +140,9 @@ const createRegexJsonParserInternal = (): {
     processChunk: async (accumulatedContent: string): Promise<AgentWidgetStreamParserResult | string | null> => {
       // Skip if no new content
       if (accumulatedContent.length <= processedLength) {
-        return extractedText ? { text: extractedText, raw: accumulatedContent } : extractedText;
+        return extractedText !== null
+          ? { text: extractedText, raw: accumulatedContent }
+          : null;
       }
       
       // Validate that the accumulated content looks like valid JSON
@@ -159,10 +161,14 @@ const createRegexJsonParserInternal = (): {
       processedLength = accumulatedContent.length;
       
       // Return both the extracted text and raw JSON
-      return extractedText ? { 
-        text: extractedText,
-        raw: accumulatedContent 
-      } : extractedText;
+      if (extractedText !== null) {
+        return {
+          text: extractedText,
+          raw: accumulatedContent
+        };
+      }
+
+      return null;
     },
     close: async () => {
       // No cleanup needed for regex-based parser
@@ -257,7 +263,9 @@ export const createJsonStreamParser = (): AgentWidgetStreamParser => {
       
       // Skip if no new content
       if (accumulatedContent.length <= processedLength) {
-        return extractedText ? { text: extractedText, raw: accumulatedContent } : extractedText;
+        return extractedText !== null
+          ? { text: extractedText, raw: accumulatedContent }
+          : null;
       }
       
       try {
@@ -278,10 +286,14 @@ export const createJsonStreamParser = (): AgentWidgetStreamParser => {
       processedLength = accumulatedContent.length;
       
       // Return both the extracted text and raw JSON
-      return extractedText ? { 
-        text: extractedText,
-        raw: accumulatedContent 
-      } : extractedText;
+      if (extractedText !== null) {
+        return {
+          text: extractedText,
+          raw: accumulatedContent
+        };
+      }
+
+      return null;
     },
     close: () => {
       // No cleanup needed

package/src/utils/storage.ts

@@ -0,0 +1,72 @@
+import type {
+  AgentWidgetMessage,
+  AgentWidgetStorageAdapter,
+  AgentWidgetStoredState
+} from "../types";
+
+const safeJsonParse = (value: string | null) => {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    if (typeof console !== "undefined") {
+      // eslint-disable-next-line no-console
+      console.error("[AgentWidget] Failed to parse stored state:", error);
+    }
+    return null;
+  }
+};
+
+const sanitizeMessages = (messages: AgentWidgetMessage[]) =>
+  messages.map((message) => ({
+    ...message,
+    streaming: false
+  }));
+
+export const createLocalStorageAdapter = (
+  key = "vanilla-agent-state"
+): AgentWidgetStorageAdapter => {
+  const getStorage = () => {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return null;
+    }
+    return window.localStorage;
+  };
+
+  return {
+    load: () => {
+      const storage = getStorage();
+      if (!storage) return null;
+      return safeJsonParse(storage.getItem(key));
+    },
+    save: (state: AgentWidgetStoredState) => {
+      const storage = getStorage();
+      if (!storage) return;
+      try {
+        const payload: AgentWidgetStoredState = {
+          ...state,
+          messages: state.messages ? sanitizeMessages(state.messages) : undefined
+        };
+        storage.setItem(key, JSON.stringify(payload));
+      } catch (error) {
+        if (typeof console !== "undefined") {
+          // eslint-disable-next-line no-console
+          console.error("[AgentWidget] Failed to persist state:", error);
+        }
+      }
+    },
+    clear: () => {
+      const storage = getStorage();
+      if (!storage) return;
+      try {
+        storage.removeItem(key);
+      } catch (error) {
+        if (typeof console !== "undefined") {
+          // eslint-disable-next-line no-console
+          console.error("[AgentWidget] Failed to clear stored state:", error);
+        }
+      }
+    }
+  };
+};
+