@adecore/agents-react 0.31.12 → 0.32.0

package/dist/prompts/logic/keys.js

@@ -4,91 +4,125 @@ import { matchesShortcut, shortcut } from '@adecore/ui';
  * is a widget the keyboard is already in. They only mean something while the focus is inside one.
  */
 export const PROMPT_SHORTCUTS = {
-    primary: shortcut('Mod+Enter'),
-    previousPrompt: shortcut('Mod+Shift+ArrowLeft'),
-    nextPrompt: shortcut('Mod+Shift+ArrowRight')
+  primary: shortcut('Mod+Enter'),
+  previousPrompt: shortcut('Mod+Shift+ArrowLeft'),
+  nextPrompt: shortcut('Mod+Shift+ArrowRight')
 };
 function isPlain(event) {
-    return !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && !event.isComposing;
+  return !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && !event.isComposing;
 }
-const LIST_KEYS = { ArrowUp: 'previous', ArrowDown: 'next', Home: 'first', End: 'last' };
-const TOOLBAR_KEYS = { ArrowLeft: 'previous', ArrowRight: 'next', Home: 'first', End: 'last' };
+const LIST_KEYS = {
+  ArrowUp: 'previous',
+  ArrowDown: 'next',
+  Home: 'first',
+  End: 'last'
+};
+const TOOLBAR_KEYS = {
+  ArrowLeft: 'previous',
+  ArrowRight: 'next',
+  Home: 'first',
+  End: 'last'
+};
 /* Both lists wrap, the way a radio group does. */
 export function stepIndex(index, count, to) {
-    if (count === 0) {
-        return -1;
-    }
-    switch (to) {
-        case 'first':
-            return 0;
-        case 'last':
-            return count - 1;
-        case 'previous':
-            return (index - 1 + count) % count;
-        case 'next':
-            return (index + 1) % count;
-    }
+  if (count === 0) {
+    return -1;
+  }
+  switch (to) {
+    case 'first':
+      return 0;
+    case 'last':
+      return count - 1;
+    case 'previous':
+      return (index - 1 + count) % count;
+    case 'next':
+      return (index + 1) % count;
+  }
 }
 /*
  * A choice of a question. Enter on a multi select question only moves on once something is chosen, so
  * the first Enter on an empty question picks the choice instead of doing nothing.
  */
-export function choiceKey(event, { multiSelect, anyChosen }) {
-    if (!isPlain(event)) {
-        return null;
-    }
-    const step = LIST_KEYS[event.key];
-    if (step) {
-        return { kind: 'move', to: step };
-    }
-    if (event.code === 'Space') {
-        return { kind: 'pick' };
-    }
-    if (event.key === 'Enter') {
-        if (!multiSelect) {
-            return { kind: 'pick-and-commit' };
-        }
-        return anyChosen ? { kind: 'commit' } : { kind: 'pick' };
-    }
+export function choiceKey(event, {
+  multiSelect,
+  anyChosen
+}) {
+  if (!isPlain(event)) {
     return null;
+  }
+  const step = LIST_KEYS[event.key];
+  if (step) {
+    return {
+      kind: 'move',
+      to: step
+    };
+  }
+  if (event.code === 'Space') {
+    return {
+      kind: 'pick'
+    };
+  }
+  if (event.key === 'Enter') {
+    if (!multiSelect) {
+      return {
+        kind: 'pick-and-commit'
+      };
+    }
+    return anyChosen ? {
+      kind: 'commit'
+    } : {
+      kind: 'pick'
+    };
+  }
+  return null;
 }
 /* A written answer: under the choices ("Something else…") or the only field of a question without choices. */
-export function answerFieldKey(event, { belowChoices, caretAtStart, hasText }) {
-    if (!isPlain(event)) {
-        return null;
-    }
-    if (event.key === 'ArrowUp' && belowChoices && caretAtStart) {
-        return { kind: 'to-last-choice' };
-    }
-    if (event.key === 'Enter') {
-        // An empty answer is not sent, and an empty line in front of the answer is never what Enter meant.
-        return hasText ? { kind: 'commit' } : { kind: 'ignore' };
-    }
+export function answerFieldKey(event, {
+  belowChoices,
+  caretAtStart,
+  hasText
+}) {
+  if (!isPlain(event)) {
     return null;
+  }
+  if (event.key === 'ArrowUp' && belowChoices && caretAtStart) {
+    return {
+      kind: 'to-last-choice'
+    };
+  }
+  if (event.key === 'Enter') {
+    // An empty answer is not sent, and an empty line in front of the answer is never what Enter meant.
+    return hasText ? {
+      kind: 'commit'
+    } : {
+      kind: 'ignore'
+    };
+  }
+  return null;
 }
 export function headingKey(event) {
-    return isPlain(event) && event.key === 'ArrowDown';
+  return isPlain(event) && event.key === 'ArrowDown';
 }
 export function toolbarKey(event) {
-    return isPlain(event) ? (TOOLBAR_KEYS[event.key] ?? null) : null;
+  return isPlain(event) ? TOOLBAR_KEYS[event.key] ?? null : null;
 }
 export function isPrimaryKey(event, apple) {
-    return !event.isComposing && matchesShortcut(PROMPT_SHORTCUTS.primary, event, apple);
+  return !event.isComposing && matchesShortcut(PROMPT_SHORTCUTS.primary, event, apple);
 }
 /* Paging through a stack. In a text field these keys select to the start or end of the line, so they stay there. */
 export function pageKey(event, apple, typing) {
-    if (typing || event.isComposing) {
-        return null;
-    }
-    if (matchesShortcut(PROMPT_SHORTCUTS.previousPrompt, event, apple)) {
-        return -1;
-    }
-    return matchesShortcut(PROMPT_SHORTCUTS.nextPrompt, event, apple) ? 1 : null;
+  if (typing || event.isComposing) {
+    return null;
+  }
+  if (matchesShortcut(PROMPT_SHORTCUTS.previousPrompt, event, apple)) {
+    return -1;
+  }
+  return matchesShortcut(PROMPT_SHORTCUTS.nextPrompt, event, apple) ? 1 : null;
 }
 /*
  * A key without Ctrl, Cmd or Alt never leaves a card: arrows would reach the canvas, Space would start a
  * pan and Backspace would delete the selected nodes. Escape and Tab still go on, since they leave the card.
  */
 export function staysInCard(event) {
-    return !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== 'Escape' && event.key !== 'Tab';
-}
+  return !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== 'Escape' && event.key !== 'Tab';
+}

package/dist/prompts/logic/prompts.js

@@ -1,32 +1,45 @@
 import { toggleChoice } from '../../chat/logic/answers.js';
 export function emptyPromptDraft() {
-    return { index: 0, answers: {}, reason: '', showReason: false };
+  return {
+    index: 0,
+    answers: {},
+    reason: '',
+    showReason: false
+  };
 }
 export function answerValue(answer) {
-    return answer.custom ? answer.text.trim() : answer.choices.join(', ');
+  return answer.custom ? answer.text.trim() : answer.choices.join(', ');
 }
 export function questionAnswer(draft, question) {
-    return draft.answers[question.id] ?? { choices: [], text: '', custom: question.choices.length === 0 };
+  return draft.answers[question.id] ?? {
+    choices: [],
+    text: '',
+    custom: question.choices.length === 0
+  };
 }
 export function pickPromptChoice(answer, question, label) {
-    return { ...answer, custom: false, choices: question.multiSelect ? toggleChoice(answer.choices, label) : [label] };
+  return {
+    ...answer,
+    custom: false,
+    choices: question.multiSelect ? toggleChoice(answer.choices, label) : [label]
+  };
 }
 /* An optional question never stands in front of a request that holds the agent up. */
 export function isBlockingPrompt(item) {
-    return item.kind === 'approval' || !item.async;
+  return item.kind === 'approval' || !item.async;
 }
 /* Blocking prompts first and optional ones after, each oldest first. The chat and a canvas's stack both follow it. */
 export function orderPrompts(prompts, blocking, createdAt) {
-    return [...prompts].sort((a, b) => Number(blocking(b)) - Number(blocking(a)) || createdAt(a) - createdAt(b));
+  return [...prompts].sort((a, b) => Number(blocking(b)) - Number(blocking(a)) || createdAt(a) - createdAt(b));
 }
 export function nextPrompt(items, activeId) {
-    const active = items.find((item) => item.requestId === activeId);
-    if (active) {
-        return active;
-    }
-    return orderPrompts(items, isBlockingPrompt, (item) => item.createdAt)[0] ?? null;
+  const active = items.find(item => item.requestId === activeId);
+  if (active) {
+    return active;
+  }
+  return orderPrompts(items, isBlockingPrompt, item => item.createdAt)[0] ?? null;
 }
 export function promptAnswers(item, draft) {
-    const answers = Object.fromEntries(item.questions.map((question) => [question.id, answerValue(questionAnswer(draft, question))]));
-    return Object.values(answers).every((answer) => answer !== '') ? answers : null;
-}
+  const answers = Object.fromEntries(item.questions.map(question => [question.id, answerValue(questionAnswer(draft, question))]));
+  return Object.values(answers).every(answer => answer !== '') ? answers : null;
+}

package/dist/prompts/logic/subjects.js

@@ -2,64 +2,78 @@ import i18next from 'i18next';
 import { isBlockingPrompt } from './prompts.js';
 /* Unique across the chats of a surface and the app's own prompts, and stable while the prompt waits. */
 export function promptIdOf(subject) {
-    return subject.kind === 'chat' ? `agent-chat:${subject.nodeId}:${subject.item.requestId}` : subject.prompt.id;
+  return subject.kind === 'chat' ? `agent-chat:${subject.nodeId}:${subject.item.requestId}` : subject.prompt.id;
 }
 export function promptCreatedAt(subject) {
-    return subject.kind === 'chat' ? subject.item.createdAt : subject.prompt.createdAt;
+  return subject.kind === 'chat' ? subject.item.createdAt : subject.prompt.createdAt;
 }
 /* Only a chat's optional question does not hold anything up; the app says so of its own. */
 export function isBlockingSubject(subject) {
-    return subject.kind === 'chat' ? isBlockingPrompt(subject.item) : subject.prompt.blocking;
+  return subject.kind === 'chat' ? isBlockingPrompt(subject.item) : subject.prompt.blocking;
 }
 /* The buttons of a chat's permission request in the order it draws them: a remembered rule, Deny, then Allow as the primary. */
 export function approvalButtons(subject, reason) {
-    if (subject.kind !== 'chat' || subject.item.kind !== 'approval') {
-        return [];
+  if (subject.kind !== 'chat' || subject.item.kind !== 'approval') {
+    return [];
+  }
+  const {
+    item
+  } = subject;
+  const message = reason.trim();
+  return [...(item.canAllowAlways && item.allowAlways ? [{
+    id: 'allow-always',
+    label: item.allowAlways.label,
+    description: item.allowAlways.description,
+    primary: false,
+    lasting: true,
+    action: {
+      kind: 'approve',
+      decision: 'allow-always'
     }
-    const { item } = subject;
-    const message = reason.trim();
-    return [
-        ...(item.canAllowAlways && item.allowAlways
-            ? [
-                {
-                    id: 'allow-always',
-                    label: item.allowAlways.label,
-                    description: item.allowAlways.description,
-                    primary: false,
-                    lasting: true,
-                    action: { kind: 'approve', decision: 'allow-always' }
-                }
-            ]
-            : []),
-        {
-            id: 'deny',
-            label: i18next.t('agent-prompts:approval.deny'),
-            primary: false,
-            action: { kind: 'approve', decision: 'deny', ...(message ? { message } : {}) }
-        },
-        { id: 'allow', label: i18next.t('agent-prompts:approval.allow'), primary: true, action: { kind: 'approve', decision: 'allow' } }
-    ];
+  }] : []), {
+    id: 'deny',
+    label: i18next.t('agent-prompts:approval.deny'),
+    primary: false,
+    action: {
+      kind: 'approve',
+      decision: 'deny',
+      ...(message ? {
+        message
+      } : {})
+    }
+  }, {
+    id: 'allow',
+    label: i18next.t('agent-prompts:approval.allow'),
+    primary: true,
+    action: {
+      kind: 'approve',
+      decision: 'allow'
+    }
+  }];
 }
 /*
  * Sends a card's action as the request its subject is answered with, or to `host` for a prompt it raised.
  * A refusal comes back as an error for the card to show.
  */
 export async function answerPrompt(subject, action, chat, host) {
-    if (subject.kind === 'host') {
-        return host.prompts.answer(subject.prompt, action);
-    }
-    if (chat === null) {
-        throw new Error(i18next.t('agent-prompts:error.notConnected'));
-    }
-    const { item, nodeId } = subject;
-    if (action.kind === 'approve') {
-        return chat.approve(nodeId, item.requestId, action.decision, action.message);
-    }
-    if (action.kind === 'answer') {
-        return chat.answer(nodeId, item.requestId, action.answers);
-    }
-    if (action.kind === 'dismiss') {
-        return chat.dismiss(nodeId, item.id);
-    }
-    throw new Error(i18next.t('agent-prompts:error.noChoices'));
-}
+  if (subject.kind === 'host') {
+    return host.prompts.answer(subject.prompt, action);
+  }
+  if (chat === null) {
+    throw new Error(i18next.t('agent-prompts:error.notConnected'));
+  }
+  const {
+    item,
+    nodeId
+  } = subject;
+  if (action.kind === 'approve') {
+    return chat.approve(nodeId, item.requestId, action.decision, action.message);
+  }
+  if (action.kind === 'answer') {
+    return chat.answer(nodeId, item.requestId, action.answers);
+  }
+  if (action.kind === 'dismiss') {
+    return chat.dismiss(nodeId, item.id);
+  }
+  throw new Error(i18next.t('agent-prompts:error.noChoices'));
+}

package/dist/prompts/logic/useFocusAfterAnswer.js

@@ -1,3 +1,4 @@
+import { c as _c } from "react/compiler-runtime";
 import { useEffect, useRef } from 'react';
 import { focusPromptStart } from './focus.js';
 /*
@@ -5,24 +6,63 @@ import { focusPromptStart } from './focus.js';
  * wherever `onEmpty` puts it once none is left. A card answered with the keyboard elsewhere takes nothing.
  */
 export function useFocusAfterAnswer(activeId, container, onEmpty) {
-    const pending = useRef(false);
-    useEffect(() => {
-        if (!pending.current) {
-            return;
-        }
-        pending.current = false;
-        if (!focusPromptStart(container.current)) {
-            onEmpty();
-        }
-        // Only a change of the front card is news; a new `onEmpty` each render is not.
-        // oxlint-disable-next-line react-hooks/exhaustive-deps
-    }, [activeId]);
-    return {
-        hold: () => {
-            pending.current = container.current?.contains(document.activeElement) === true;
-        },
-        release: () => {
-            pending.current = false;
-        }
+  const $ = _c(10);
+  const pending = useRef(false);
+  let t0;
+  if ($[0] !== container || $[1] !== onEmpty) {
+    t0 = () => {
+      if (!pending.current) {
+        return;
+      }
+      pending.current = false;
+      if (!focusPromptStart(container.current)) {
+        onEmpty();
+      }
     };
-}
+    $[0] = container;
+    $[1] = onEmpty;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== activeId) {
+    t1 = [activeId];
+    $[3] = activeId;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  useEffect(t0, t1);
+  let t2;
+  if ($[5] !== container) {
+    t2 = () => {
+      pending.current = container.current?.contains(document.activeElement) === true;
+    };
+    $[5] = container;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  let t3;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = () => {
+      pending.current = false;
+    };
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== t2) {
+    t4 = {
+      hold: t2,
+      release: t3
+    };
+    $[8] = t2;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
+}

package/dist/prompts/logic/usePromptSession.js

@@ -5,83 +5,94 @@ import { emptyPromptDraft } from './prompts.js';
  * paging, one send at a time, the error of the request that failed, and the requests answered here
  * that the machine has not taken off yet.
  */
-export function usePromptSession({ prompts, idOf, pick, disabled }) {
-    const [activeId, setActiveId] = useState(null);
-    const [activeIndex, setActiveIndex] = useState(0);
-    const [completed, setCompleted] = useState([]);
-    const [drafts, setDrafts] = useState({});
-    const [sending, setSending] = useState(false);
-    const [error, setError] = useState(null);
-    const busy = useRef(false);
-    const pressedRequest = useRef(null);
-    const stillCompleted = completed.filter((id) => prompts.some((prompt) => idOf(prompt) === id));
-    if (stillCompleted.length !== completed.length) {
-        setCompleted(stillCompleted);
+export function usePromptSession({
+  prompts,
+  idOf,
+  pick,
+  disabled
+}) {
+  const [activeId, setActiveId] = useState(null);
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [completed, setCompleted] = useState([]);
+  const [drafts, setDrafts] = useState({});
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState(null);
+  const busy = useRef(false);
+  const pressedRequest = useRef(null);
+  const stillCompleted = completed.filter(id => prompts.some(prompt => idOf(prompt) === id));
+  if (stillCompleted.length !== completed.length) {
+    setCompleted(stillCompleted);
+  }
+  const waiting = prompts.filter(prompt_0 => !completed.includes(idOf(prompt_0)));
+  const active = pick(waiting, activeId, activeIndex);
+  const activeKey = active === null ? null : idOf(active);
+  const index = active === null ? 0 : waiting.indexOf(active);
+  if (index !== activeIndex) {
+    setActiveIndex(index);
+  }
+  if (activeKey !== activeId) {
+    setActiveId(activeKey);
+    setError(null);
+  }
+  const finish = id_0 => {
+    setCompleted(current => [...current, id_0]);
+    setDrafts(current_0 => {
+      const next = {
+        ...current_0
+      };
+      delete next[id_0];
+      return next;
+    });
+  };
+  const act = async (prompt_1, send) => {
+    if (busy.current || disabled) {
+      return 'busy';
     }
-    const waiting = prompts.filter((prompt) => !completed.includes(idOf(prompt)));
-    const active = pick(waiting, activeId, activeIndex);
-    const activeKey = active === null ? null : idOf(active);
-    const index = active === null ? 0 : waiting.indexOf(active);
-    if (index !== activeIndex) {
-        setActiveIndex(index);
+    const id_1 = idOf(prompt_1);
+    busy.current = true;
+    setSending(true);
+    setError(null);
+    try {
+      await send();
+      finish(id_1);
+      return 'sent';
+    } catch (cause) {
+      setError({
+        id: id_1,
+        message: cause instanceof Error ? cause.message : String(cause)
+      });
+      return 'failed';
+    } finally {
+      busy.current = false;
+      setSending(false);
     }
-    if (activeKey !== activeId) {
-        setActiveId(activeKey);
-        setError(null);
+  };
+  return {
+    active,
+    activeId: activeKey,
+    index,
+    waiting,
+    setActive: id_2 => {
+      setActiveId(id_2);
+      setError(null);
+    },
+    draftOf: id_3 => drafts[id_3] ?? emptyPromptDraft(),
+    setDraft: (id_4, draft) => setDrafts(current_1 => ({
+      ...current_1,
+      [id_4]: draft
+    })),
+    sending,
+    errorOf: id_5 => error?.id === id_5 ? error.message : null,
+    act,
+    onPointerDownCapture: () => {
+      pressedRequest.current = activeKey;
+    },
+    onClickCapture: event => {
+      // A press that began on Send cannot become Allow when a request arrives underneath it.
+      if (event.detail > 0 && event.target.closest('.prompt-card') && pressedRequest.current !== activeKey) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
     }
-    const finish = (id) => {
-        setCompleted((current) => [...current, id]);
-        setDrafts((current) => {
-            const next = { ...current };
-            delete next[id];
-            return next;
-        });
-    };
-    const act = async (prompt, send) => {
-        if (busy.current || disabled) {
-            return 'busy';
-        }
-        const id = idOf(prompt);
-        busy.current = true;
-        setSending(true);
-        setError(null);
-        try {
-            await send();
-            finish(id);
-            return 'sent';
-        }
-        catch (cause) {
-            setError({ id, message: cause instanceof Error ? cause.message : String(cause) });
-            return 'failed';
-        }
-        finally {
-            busy.current = false;
-            setSending(false);
-        }
-    };
-    return {
-        active,
-        activeId: activeKey,
-        index,
-        waiting,
-        setActive: (id) => {
-            setActiveId(id);
-            setError(null);
-        },
-        draftOf: (id) => drafts[id] ?? emptyPromptDraft(),
-        setDraft: (id, draft) => setDrafts((current) => ({ ...current, [id]: draft })),
-        sending,
-        errorOf: (id) => (error?.id === id ? error.message : null),
-        act,
-        onPointerDownCapture: () => {
-            pressedRequest.current = activeKey;
-        },
-        onClickCapture: (event) => {
-            // A press that began on Send cannot become Allow when a request arrives underneath it.
-            if (event.detail > 0 && event.target.closest('.prompt-card') && pressedRequest.current !== activeKey) {
-                event.preventDefault();
-                event.stopPropagation();
-            }
-        }
-    };
-}
+  };
+}