@lunora/solid 1.0.0-alpha.23 → 1.0.0-alpha.24

package/dist/packem_shared/createAgent-D7EZBeql.mjs

@@ -0,0 +1,55 @@
+import { createMemo } from 'solid-js';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const resolveMaybe = (value) => typeof value === "function" ? value() : value;
+const createAgent = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    run: runReference,
+    runArgs,
+    threadKey
+  } = options;
+  const runMutation = createMutation(runReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const run = async (input, arguments_) => {
+    await runMutation.mutate({
+      input,
+      threadKey: resolveMaybe(threadKey),
+      ...runArgs,
+      ...arguments_
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    cancel,
+    pending: runMutation.pending,
+    run,
+    status,
+    thread
+  };
+};
+
+export { NO_MUTATION_REF, createAgent, resolveMaybe };

package/dist/packem_shared/createAgentChat-CsoyE3RE.mjs

@@ -0,0 +1,150 @@
+import { createSignal, createMemo } from 'solid-js';
+import { resolveMaybe, NO_MUTATION_REF } from './createAgent-D7EZBeql.mjs';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const reconcileOptimistic = (optimistic, durable) => {
+  const pool = durable.filter((message) => message.role === "user").map((message) => message.content);
+  return optimistic.filter((pending) => {
+    const index = pool.indexOf(pending.content);
+    if (index !== -1) {
+      pool.splice(index, 1);
+      return false;
+    }
+    return true;
+  });
+};
+const createAgentChat = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    limit,
+    send: sendReference,
+    sendArgs,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  });
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = createMutation(sendReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = createMutation(api.agents.agentResolveApproval);
+  const [optimistic, setOptimistic] = createSignal([]);
+  let nextId = 0;
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const durable = createMemo(() => history() ?? []);
+  const messages = createMemo(() => {
+    const rows = durable();
+    const visible = reconcileOptimistic(optimistic(), rows);
+    if (visible.length === 0) {
+      return rows;
+    }
+    return [...rows, ...visible.map((pending, index) => {
+      return {
+        content: pending.content,
+        optimistic: true,
+        role: "user",
+        seq: rows.length + index
+      };
+    })];
+  });
+  const streamingText = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const assistantCount = durable().filter((message) => message.role === "assistant").length;
+    return chunks().filter((event) => event.kind !== "progress" && event.threadKey === key && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    setOptimistic((previous) => [...reconcileOptimistic(previous, durable()), {
+      content: input,
+      id
+    }]);
+    await sendMutation.mutate({
+      input,
+      threadKey: resolveMaybe(threadKey),
+      ...sendArgs,
+      ...arguments_
+    });
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "approve",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "reject",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    approve,
+    cancel,
+    messages,
+    reject,
+    send,
+    status,
+    streamingText
+  };
+};
+
+export { createAgentChat };

package/dist/packem_shared/createAgentState-DckYu3G8.mjs

@@ -0,0 +1,21 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const createAgentState = (options) => {
+  const {
+    data,
+    error
+  } = createSubscription(options.api.agents.agentState, () => {
+    return {
+      key: resolveMaybe(options.threadKey)
+    };
+  });
+  const state = createMemo(() => data());
+  return {
+    error,
+    state
+  };
+};
+
+export { createAgentState };

package/dist/packem_shared/createAgentToolEvents-UavTO16u.mjs

@@ -0,0 +1,99 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.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 createAgentToolEvents = (options) => {
+  const {
+    api,
+    limit,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const messagesArguments = () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  };
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, messagesArguments);
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const events = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const durable = history() ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks()) {
+      if (event.kind === "progress" && event.threadKey === key) {
+        derived.push({
+          data: event.data,
+          toolCallId: event.toolCallId,
+          type: "progress"
+        });
+      }
+    }
+    return derived;
+  });
+  return {
+    events
+  };
+};
+
+export { createAgentToolEvents };

package/dist/packem_shared/createStream-D9ONbGAw.mjs

@@ -0,0 +1,70 @@
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+
+const createStream = (function_, args, options = {}) => {
+  const client = useLunora();
+  const [chunks, setChunks] = createSignal([]);
+  const [error, setError] = createSignal(void 0);
+  const [status, setStatus] = createSignal("idle");
+  const resolveArgs = typeof args === "function" ? args : () => args;
+  let cancelCurrent;
+  const cancel = () => {
+    cancelCurrent?.();
+  };
+  createEffect(on(resolveArgs, (currentArgs) => {
+    setChunks(() => []);
+    setError(() => void 0);
+    if (currentArgs === "skip") {
+      setStatus("idle");
+      return;
+    }
+    setStatus("streaming");
+    let active = true;
+    const iterable = client.stream(function_, currentArgs, {
+      maxBuffer: options.maxBuffer,
+      shardKey: options.shardKey
+    });
+    const cancelIterable = () => {
+      iterable.cancel();
+    };
+    cancelCurrent = cancelIterable;
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!active) {
+            return;
+          }
+          setChunks((previous) => [...previous, chunk]);
+        }
+        if (active) {
+          setStatus("complete");
+        }
+      } catch (streamError) {
+        if (!active) {
+          return;
+        }
+        setError(() => streamError instanceof Error ? streamError : new Error(String(streamError)));
+        setStatus("error");
+      }
+    })().catch(() => {
+    });
+    onCleanup(() => {
+      active = false;
+      cancelIterable();
+      if (cancelCurrent === cancelIterable) {
+        cancelCurrent = void 0;
+      }
+    });
+  }));
+  onCleanup(() => {
+    cancel();
+  });
+  return {
+    cancel,
+    chunks,
+    error,
+    status
+  };
+};
+
+export { createStream };