@lunora/react 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/packem_shared/useAgentChat-0cebQe7-.mjs

@@ -0,0 +1,304 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useState, useRef } from 'react';
+import { useMutation } from './useMutation-BeqeIjTr.mjs';
+import { useStream } from './useStream-GYNgc9J5.mjs';
+import useSubscription from './useSubscription-DcDlvVuI.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const reconcileOptimistic = (optimistic, durable) => {
+  const durableUserRows = durable.filter((message) => message.role === "user");
+  const consumed = /* @__PURE__ */ new Set();
+  return optimistic.filter((pending) => {
+    for (let index = pending.durableUserCountAtSend; index < durableUserRows.length; index += 1) {
+      const row = durableUserRows[index];
+      if (row !== void 0 && !consumed.has(index) && row.content === pending.content) {
+        consumed.add(index);
+        return false;
+      }
+    }
+    return true;
+  });
+};
+const useAgentChat = (options) => {
+  const $ = c(49);
+  const {
+    api,
+    cancel: cancelReference,
+    limit,
+    send: sendReference,
+    sendArgs,
+    stream: streamReference,
+    threadKey
+  } = options;
+  let t0;
+  if ($[0] !== limit || $[1] !== threadKey) {
+    t0 = limit === void 0 ? {
+      key: threadKey
+    } : {
+      key: threadKey,
+      limit
+    };
+    $[0] = limit;
+    $[1] = threadKey;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const messagesArguments = t0;
+  const {
+    data: history
+  } = useSubscription(api.agents.agentMessages, messagesArguments);
+  let t1;
+  if ($[3] !== threadKey) {
+    t1 = {
+      key: threadKey
+    };
+    $[3] = threadKey;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const {
+    data: threadData
+  } = useSubscription(api.agents.agentThread, t1);
+  let t2;
+  if ($[5] !== streamReference || $[6] !== threadKey) {
+    t2 = streamReference === void 0 ? "skip" : {
+      key: threadKey
+    };
+    $[5] = streamReference;
+    $[6] = threadKey;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const streamArguments = t2;
+  const {
+    chunks
+  } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = useMutation(sendReference);
+  const cancelMutation = useMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = useMutation(api.agents.agentResolveApproval);
+  let t3;
+  if ($[8] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [];
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const [optimistic, setOptimistic] = useState(t3);
+  const nextIdRef = useRef(0);
+  const thread = threadData;
+  const status = thread?.status;
+  const instanceId = thread?.instanceId;
+  const durable = history ?? EMPTY_MESSAGES;
+  let t4;
+  if ($[9] !== durable || $[10] !== optimistic) {
+    const visibleOptimistic = reconcileOptimistic(optimistic, durable);
+    let maxDurableSeq;
+    if ($[12] !== durable) {
+      maxDurableSeq = -1;
+      for (const message of durable) {
+        if (message.seq > maxDurableSeq) {
+          maxDurableSeq = message.seq;
+        }
+      }
+      $[12] = durable;
+      $[13] = maxDurableSeq;
+    } else {
+      maxDurableSeq = $[13];
+    }
+    t4 = visibleOptimistic.length === 0 ? durable : [...durable, ...visibleOptimistic.map((pending, index) => ({
+      content: pending.content,
+      optimistic: true,
+      role: "user",
+      seq: maxDurableSeq + 1 + index
+    }))];
+    $[9] = durable;
+    $[10] = optimistic;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  const messages = t4;
+  let t5;
+  if ($[14] !== durable) {
+    t5 = durable.filter(_temp);
+    $[14] = durable;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  const assistantCount = t5.length;
+  let t6;
+  if ($[16] !== assistantCount || $[17] !== chunks || $[18] !== threadKey) {
+    let t72;
+    if ($[20] !== assistantCount || $[21] !== threadKey) {
+      t72 = (event) => event.kind !== "progress" && event.threadKey === threadKey && event.turn >= assistantCount;
+      $[20] = assistantCount;
+      $[21] = threadKey;
+      $[22] = t72;
+    } else {
+      t72 = $[22];
+    }
+    t6 = chunks.filter(t72).map(_temp2).join("");
+    $[16] = assistantCount;
+    $[17] = chunks;
+    $[18] = threadKey;
+    $[19] = t6;
+  } else {
+    t6 = $[19];
+  }
+  const streamingText = t6;
+  const {
+    mutate: sendMutate
+  } = sendMutation;
+  const {
+    mutate: cancelMutate
+  } = cancelMutation;
+  const {
+    mutate: resolveMutate
+  } = approvalMutation;
+  let t7;
+  if ($[23] !== durable || $[24] !== sendArgs || $[25] !== sendMutate || $[26] !== threadKey) {
+    t7 = async (input, args) => {
+      const id = nextIdRef.current;
+      nextIdRef.current = nextIdRef.current + 1;
+      const durableUserCountAtSend = durable.filter(_temp3).length;
+      setOptimistic((previous) => [...reconcileOptimistic(previous, durable), {
+        content: input,
+        durableUserCountAtSend,
+        id
+      }]);
+      try {
+        await sendMutate({
+          input,
+          threadKey,
+          ...sendArgs,
+          ...args
+        });
+      } catch (t82) {
+        const error = t82;
+        setOptimistic((previous_0) => previous_0.filter((pending_0) => pending_0.id !== id));
+        throw error;
+      }
+    };
+    $[23] = durable;
+    $[24] = sendArgs;
+    $[25] = sendMutate;
+    $[26] = threadKey;
+    $[27] = t7;
+  } else {
+    t7 = $[27];
+  }
+  const send = t7;
+  let t8;
+  if ($[28] !== instanceId || $[29] !== resolveMutate || $[30] !== threadKey) {
+    t8 = async (toolCallId, note) => {
+      if (instanceId === void 0) {
+        throw new Error("useAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+      }
+      await resolveMutate({
+        decision: "approve",
+        instanceId,
+        threadKey,
+        toolCallId,
+        ...note === void 0 ? {} : {
+          note
+        }
+      });
+    };
+    $[28] = instanceId;
+    $[29] = resolveMutate;
+    $[30] = threadKey;
+    $[31] = t8;
+  } else {
+    t8 = $[31];
+  }
+  const approve = t8;
+  let t9;
+  if ($[32] !== instanceId || $[33] !== resolveMutate || $[34] !== threadKey) {
+    t9 = async (toolCallId_0, note_0) => {
+      if (instanceId === void 0) {
+        throw new Error("useAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+      }
+      await resolveMutate({
+        decision: "reject",
+        instanceId,
+        threadKey,
+        toolCallId: toolCallId_0,
+        ...note_0 === void 0 ? {} : {
+          note: note_0
+        }
+      });
+    };
+    $[32] = instanceId;
+    $[33] = resolveMutate;
+    $[34] = threadKey;
+    $[35] = t9;
+  } else {
+    t9 = $[35];
+  }
+  const reject = t9;
+  let t10;
+  if ($[36] !== cancelMutate || $[37] !== cancelReference || $[38] !== instanceId || $[39] !== threadKey) {
+    t10 = async () => {
+      if (cancelReference === void 0 || instanceId === void 0) {
+        return;
+      }
+      await cancelMutate({
+        instanceId,
+        threadKey
+      });
+    };
+    $[36] = cancelMutate;
+    $[37] = cancelReference;
+    $[38] = instanceId;
+    $[39] = threadKey;
+    $[40] = t10;
+  } else {
+    t10 = $[40];
+  }
+  const cancel = t10;
+  let t11;
+  if ($[41] !== approve || $[42] !== cancel || $[43] !== messages || $[44] !== reject || $[45] !== send || $[46] !== status || $[47] !== streamingText) {
+    t11 = {
+      approve,
+      cancel,
+      messages,
+      reject,
+      send,
+      status,
+      streamingText
+    };
+    $[41] = approve;
+    $[42] = cancel;
+    $[43] = messages;
+    $[44] = reject;
+    $[45] = send;
+    $[46] = status;
+    $[47] = streamingText;
+    $[48] = t11;
+  } else {
+    t11 = $[48];
+  }
+  return t11;
+};
+function _temp(message_0) {
+  return message_0.role === "assistant";
+}
+function _temp2(delta) {
+  return delta.text;
+}
+function _temp3(message_1) {
+  return message_1.role === "user";
+}
+
+export { useAgentChat };

package/dist/packem_shared/useAgentState-Cqyd3Dfy.mjs

@@ -0,0 +1,37 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import useSubscription from './useSubscription-DcDlvVuI.mjs';
+
+const useAgentState = (options) => {
+  const $ = c(5);
+  let t0;
+  if ($[0] !== options.threadKey) {
+    t0 = {
+      key: options.threadKey
+    };
+    $[0] = options.threadKey;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    data,
+    error
+  } = useSubscription(options.api.agents.agentState, t0);
+  const t1 = data;
+  let t2;
+  if ($[2] !== error || $[3] !== t1) {
+    t2 = {
+      error,
+      state: t1
+    };
+    $[2] = error;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+};
+
+export { useAgentState };

package/dist/packem_shared/useAgentToolEvents-gF7U4_KY.mjs

@@ -0,0 +1,129 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useStream } from './useStream-GYNgc9J5.mjs';
+import useSubscription from './useSubscription-DcDlvVuI.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const toDurableEvent = (message) => {
+  if (message.role === "assistant" && message.toolCalls) {
+    return message.toolCalls.map((call) => {
+      return {
+        input: call.input,
+        seq: message.seq,
+        toolCallId: call.id,
+        toolName: call.name,
+        type: "call"
+      };
+    });
+  }
+  if (message.role !== "tool") {
+    return void 0;
+  }
+  if (message.status === "awaiting_approval") {
+    return [{
+      seq: message.seq,
+      type: "awaiting-approval",
+      ...message.toolCallId === void 0 ? {} : {
+        toolCallId: message.toolCallId
+      },
+      ...message.toolName === void 0 ? {} : {
+        toolName: message.toolName
+      }
+    }];
+  }
+  return [{
+    output: message.content,
+    seq: message.seq,
+    type: "result",
+    ...message.status === "approved" || message.status === "rejected" ? {
+      status: message.status
+    } : {},
+    ...message.toolCallId === void 0 ? {} : {
+      toolCallId: message.toolCallId
+    },
+    ...message.toolName === void 0 ? {} : {
+      toolName: message.toolName
+    }
+  }];
+};
+const useAgentToolEvents = (options) => {
+  const $ = c(12);
+  const {
+    api,
+    limit,
+    stream: streamReference,
+    threadKey
+  } = options;
+  let t0;
+  if ($[0] !== limit || $[1] !== threadKey) {
+    t0 = limit === void 0 ? {
+      key: threadKey
+    } : {
+      key: threadKey,
+      limit
+    };
+    $[0] = limit;
+    $[1] = threadKey;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const messagesArguments = t0;
+  const {
+    data: history
+  } = useSubscription(api.agents.agentMessages, messagesArguments);
+  let t1;
+  if ($[3] !== streamReference || $[4] !== threadKey) {
+    t1 = streamReference === void 0 ? "skip" : {
+      key: threadKey
+    };
+    $[3] = streamReference;
+    $[4] = threadKey;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const streamArguments = t1;
+  const {
+    chunks
+  } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const durable = history ?? EMPTY_MESSAGES;
+  let events;
+  if ($[6] !== chunks || $[7] !== durable || $[8] !== threadKey) {
+    events = durable.flatMap(_temp);
+    for (const event of chunks) {
+      if (event.kind === "progress" && event.threadKey === threadKey) {
+        events.push({
+          data: event.data,
+          toolCallId: event.toolCallId,
+          type: "progress"
+        });
+      }
+    }
+    $[6] = chunks;
+    $[7] = durable;
+    $[8] = threadKey;
+    $[9] = events;
+  } else {
+    events = $[9];
+  }
+  let t2;
+  if ($[10] !== events) {
+    t2 = {
+      events
+    };
+    $[10] = events;
+    $[11] = t2;
+  } else {
+    t2 = $[11];
+  }
+  return t2;
+};
+function _temp(message) {
+  return toDurableEvent(message) ?? [];
+}
+
+export { useAgentToolEvents };

package/dist/packem_shared/{useAuth-CNUKtOOp.mjs → useAuth-BSutjJaa.mjs}

@@ -1,7 +1,7 @@
 'use client';
 import { c } from 'react/compiler-runtime';
 import { useSyncExternalStore } from 'react';
-import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
 
 const stores = /* @__PURE__ */ new WeakMap();
 const createStore = (client) => {

package/dist/packem_shared/{useAuthState-BiGhtSCs.mjs → useAuthState-CyF35qZR.mjs}

@@ -1,7 +1,7 @@
 'use client';
 import { c } from 'react/compiler-runtime';
 import { useSyncExternalStore } from 'react';
-import useAuth from './useAuth-CNUKtOOp.mjs';
+import useAuth from './useAuth-BSutjJaa.mjs';
 
 const subscribe = () => () => void 0;
 const useAuthState = () => {

package/dist/packem_shared/useClientQuery-DIkNT4QA.mjs

@@ -0,0 +1,17 @@
+'use client';
+import { useCallback, useSyncExternalStore } from 'react';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
+
+const useClientQuery = (ref) => {
+  const client = useLunora();
+  const subscribe = useCallback((onStoreChange) => client.subscribeClientQuery(ref, () => {
+    onStoreChange();
+  }), [client, ref.key]);
+  const value = useSyncExternalStore(subscribe, () => client.getClientQuery(ref), () => client.getClientQuery(ref));
+  const setter = useCallback((next) => {
+    client.setClientQuery(ref, next);
+  }, [client, ref]);
+  return [value, setter];
+};
+
+export { useClientQuery as default };

package/dist/packem_shared/{useConnectionStatus-DRSY9ldm.mjs → useConnectionStatus-PJ7vyCHy.mjs}

@@ -1,7 +1,7 @@
 'use client';
 import { c } from 'react/compiler-runtime';
 import { useSyncExternalStore } from 'react';
-import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
 
 const useConnectionStatus = () => {
   const $ = c(4);

package/dist/packem_shared/useFlag-Beyeiq2b.mjs

@@ -0,0 +1,128 @@
+'use client';
+import { useState, useRef, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-BsuiW4Lk.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
+
+const FLAGS_EVAL_PATH = "__lunora_flags__:eval";
+const flagKind = (value) => {
+  const kind = typeof value;
+  if (kind === "boolean" || kind === "number" || kind === "string") {
+    return kind;
+  }
+  return "object";
+};
+const flagsReference = {
+  __lunoraRef: FLAGS_EVAL_PATH
+};
+const useFlag = (key, defaultValue, context) => {
+  const client = useLunora();
+  const [value, setValue] = useState(defaultValue);
+  const type = flagKind(defaultValue);
+  const serializedContext = context === void 0 ? "" : stableStringify(context);
+  const resetKey = `${key}::${type}::${serializedContext}`;
+  const resetKeyRef = useRef(resetKey);
+  if (resetKeyRef.current !== resetKey) {
+    resetKeyRef.current = resetKey;
+    setValue(defaultValue);
+  }
+  const latest = useRef({
+    context,
+    defaultValue
+  });
+  useEffect(() => {
+    latest.current = {
+      context,
+      defaultValue
+    };
+  });
+  useEffect(() => {
+    let cancelled = false;
+    const {
+      context: currentContext,
+      defaultValue: currentDefault
+    } = latest.current;
+    setValue(currentDefault);
+    let unsubscribe;
+    try {
+      unsubscribe = client.subscribe(flagsReference, {
+        context: currentContext,
+        default: currentDefault,
+        key,
+        type
+      }, (next) => {
+        if (!cancelled) {
+          setValue(next);
+        }
+      });
+    } catch {
+      return () => {
+        cancelled = true;
+      };
+    }
+    return () => {
+      cancelled = true;
+      unsubscribe();
+    };
+  }, [client, key, type, serializedContext]);
+  return value;
+};
+const useFlags = (flags, context) => {
+  const client = useLunora();
+  const [values, setValues] = useState(flags);
+  const spec = stableStringify(flags);
+  const serializedContext = context === void 0 ? "" : stableStringify(context);
+  const resetKey = `${spec}::${serializedContext}`;
+  const resetKeyRef = useRef(resetKey);
+  if (resetKeyRef.current !== resetKey) {
+    resetKeyRef.current = resetKey;
+    setValues(flags);
+  }
+  const latest = useRef({
+    context,
+    flags
+  });
+  useEffect(() => {
+    latest.current = {
+      context,
+      flags
+    };
+  });
+  useEffect(() => {
+    let cancelled = false;
+    const {
+      context: currentContext,
+      flags: currentFlags
+    } = latest.current;
+    setValues(currentFlags);
+    const unsubscribes = [];
+    for (const [key, defaultValue] of Object.entries(currentFlags)) {
+      try {
+        unsubscribes.push(client.subscribe(flagsReference, {
+          context: currentContext,
+          default: defaultValue,
+          key,
+          type: flagKind(defaultValue)
+        }, (next) => {
+          if (!cancelled) {
+            setValues((previous) => {
+              return {
+                ...previous,
+                [key]: next
+              };
+            });
+          }
+        }));
+      } catch {
+      }
+    }
+    return () => {
+      cancelled = true;
+      for (const unsubscribe of unsubscribes) {
+        unsubscribe();
+      }
+    };
+  }, [client, spec, serializedContext]);
+  return values;
+};
+
+export { useFlag, useFlags };