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

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/{createFlag-Bu9YfzcJ.mjs → createFlag-DQoGdUMB.mjs}

@@ -1,5 +1,5 @@
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const FLAGS_EVAL_PATH = "__lunora_flags__:eval";

package/dist/packem_shared/{createInfiniteQuery-Dy9k7Px2.mjs → createInfiniteQuery-DwajCO2G.mjs}

@@ -1,8 +1,106 @@
 import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
 import { createMemo, createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+
+const TAG = "$lunora.wire$";
+const MAX_DEPTH = 64;
+const encodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === void 0) {
+    return [TAG, "undefined"];
+  }
+  if (value === null) {
+    return null;
+  }
+  const kind = typeof value;
+  if (kind === "bigint") {
+    return [TAG, "bigint", value.toString()];
+  }
+  if (kind === "number") {
+    const numeric = value;
+    if (Number.isNaN(numeric)) {
+      return [TAG, "nan"];
+    }
+    if (numeric === Infinity) {
+      return [TAG, "inf"];
+    }
+    if (numeric === -Infinity) {
+      return [TAG, "-inf"];
+    }
+    return numeric;
+  }
+  if (kind !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
+  }
+  if (value instanceof Error) {
+    const error = value;
+    const properties = {};
+    for (const key of Object.keys(error)) {
+      if (error[key] !== void 0) {
+        properties[key] = encodeWire(error[key], depth + 1);
+      }
+    }
+    const encodedError = [TAG, "error", error.name, error.message, properties];
+    if (error.cause !== void 0) {
+      encodedError.push(encodeWire(error.cause, depth + 1));
+    }
+    return encodedError;
+  }
+  if (value instanceof URL) {
+    return [TAG, "url", value.href];
+  }
+  if (value instanceof Map) {
+    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
+  }
+  if (value instanceof Set) {
+    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
+  }
+  if (value instanceof ArrayBuffer) {
+    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    const ctorName = view.constructor.name;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
+  }
+  if (Array.isArray(value)) {
+    const encoded = value.map((item) => encodeWire(item, depth + 1));
+    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`wire-codec: cannot encode a ${name} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`);
+  }
+  const source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const field = source[key];
+    if (field !== void 0) {
+      result[key] = encodeWire(field, depth + 1);
+    }
+  }
+  return result;
+};
+
+const stableWireKey = (value) => stableStringify(encodeWire(value));
+
 const buildPageArgs = (page, baseArgs) => {
   return {
     ...baseArgs,
@@ -13,7 +111,7 @@ const buildPageArgs = (page, baseArgs) => {
     }
   };
 };
-const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableStringify(pageArgs)}`;
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableWireKey(pageArgs)}`;
 const createPaginatedCore = (function_, args, options) => {
   const client = useLunora();
   const {

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 };