@lunora/agent 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/runVoiceTurn-LnqLvCRR.mjs

@@ -0,0 +1,211 @@
+import { f as fromBase64 } from './base64-BVwtgRJV.mjs';
+import { buildModelMessages } from './buildModelMessages-BWFigaoo.mjs';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const PCM_SAMPLE_RATE = 16e3;
+const PCM_CHANNELS = 1;
+const PCM_BITS_PER_SAMPLE = 16;
+const SENTENCE_BOUNDARY = /[^.!?]*[.!?]+\s+/u;
+const toByteIterable = async function* (source) {
+  if (source instanceof Uint8Array) {
+    yield source;
+    return;
+  }
+  if (source instanceof ReadableStream) {
+    const reader = source.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return;
+  }
+  yield* source;
+};
+const pcmToWav = (pcm, sampleRate = PCM_SAMPLE_RATE, channels = PCM_CHANNELS, bitsPerSample = PCM_BITS_PER_SAMPLE) => {
+  const blockAlign = channels * bitsPerSample / 8;
+  const byteRate = sampleRate * blockAlign;
+  const buffer = new ArrayBuffer(44 + pcm.byteLength);
+  const view = new DataView(buffer);
+  const writeAscii = (offset, text) => {
+    for (let index = 0; index < text.length; index += 1) {
+      view.setUint8(offset + index, text.codePointAt(index) ?? 0);
+    }
+  };
+  writeAscii(0, "RIFF");
+  view.setUint32(4, 36 + pcm.byteLength, true);
+  writeAscii(8, "WAVE");
+  writeAscii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeAscii(36, "data");
+  view.setUint32(40, pcm.byteLength, true);
+  const out = new Uint8Array(buffer);
+  out.set(pcm, 44);
+  return out;
+};
+const takeSentences = (buffer) => {
+  const sentences = [];
+  let rest = buffer;
+  let match = SENTENCE_BOUNDARY.exec(rest);
+  while (match && match[0].length > 0) {
+    const consumed = match[0];
+    const sentence = consumed.trim();
+    if (sentence.length > 0) {
+      sentences.push(sentence);
+    }
+    rest = rest.slice(consumed.length);
+    match = SENTENCE_BOUNDARY.exec(rest);
+  }
+  return { rest, sentences };
+};
+const runVoiceTurn = async (options) => {
+  const {
+    agent,
+    connectionId,
+    env,
+    exportName,
+    owner,
+    paths,
+    pcm,
+    run,
+    send,
+    sendAudio,
+    signal,
+    streamGenerate,
+    synthesize,
+    text,
+    threadKey,
+    transcribe,
+    turn,
+    waitForDrain
+  } = options;
+  const isAborted = () => signal.aborted;
+  const appendMessage = toFunctionReference(paths.appendMessage);
+  const ensureThread = toFunctionReference(paths.ensureThread);
+  const listMessages = toFunctionReference(paths.listMessages);
+  const patchThread = toFunctionReference(paths.patchThread);
+  const userText = (text ?? (pcm ? await transcribe(pcm) : "")).trim();
+  if (userText.length === 0) {
+    return { assistantText: "", interrupted: false, userText: "" };
+  }
+  send({ text: userText, type: "user_transcript" });
+  await run(ensureThread, {
+    agent: exportName,
+    key: threadKey,
+    ...agent.initialState === void 0 ? {} : { initialState: agent.initialState },
+    ...owner === void 0 ? {} : { owner }
+  });
+  await run(appendMessage, { content: userText, messageKey: `voice:${connectionId}:${String(turn)}:user`, role: "user", threadKey });
+  await run(patchThread, { key: threadKey, status: "running" });
+  const instructions = typeof agent.instructions === "function" ? agent.instructions({ env, input: userText, threadKey }) : agent.instructions;
+  const history = await run(listMessages, { key: threadKey });
+  const messages = buildModelMessages({ history, ...instructions === void 0 ? {} : { instructions } });
+  let pending = "";
+  let spoken = "";
+  let ttsChain = Promise.resolve();
+  const speak = async (sentence) => {
+    if (isAborted() || sentence.length === 0) {
+      return;
+    }
+    let flushed = false;
+    try {
+      for await (const chunk of toByteIterable(await synthesize(sentence, signal))) {
+        if (isAborted()) {
+          break;
+        }
+        await waitForDrain?.();
+        if (isAborted()) {
+          break;
+        }
+        sendAudio(chunk);
+        flushed = true;
+      }
+    } catch (error) {
+      send({ message: error instanceof Error ? error.message : String(error), type: "error" });
+    }
+    if (flushed) {
+      spoken = spoken.length > 0 ? `${spoken} ${sentence}` : sentence;
+    }
+  };
+  const enqueueSpeak = (sentence) => {
+    ttsChain = ttsChain.then(async () => speak(sentence));
+  };
+  try {
+    const result = await streamGenerate({ messages, signal }, (delta) => {
+      if (isAborted()) {
+        return;
+      }
+      send({ text: delta, type: "assistant_delta" });
+      pending += delta;
+      const { rest, sentences } = takeSentences(pending);
+      pending = rest;
+      for (const sentence of sentences) {
+        enqueueSpeak(sentence);
+      }
+    });
+    if (!isAborted() && pending.trim().length > 0) {
+      enqueueSpeak(pending.trim());
+    }
+    pending = "";
+    await ttsChain;
+    const interrupted = isAborted();
+    const assistantText = interrupted ? spoken : result.text;
+    await run(appendMessage, { content: assistantText, messageKey: `voice:${connectionId}:${String(turn)}:assistant`, role: "assistant", threadKey });
+    await run(patchThread, { key: threadKey, status: "idle" });
+    send(interrupted ? { type: "interrupted" } : { text: assistantText, type: "assistant_done" });
+    return { assistantText, interrupted, userText };
+  } catch (error) {
+    await run(patchThread, { key: threadKey, status: "idle" });
+    throw error;
+  }
+};
+const parseIdentity = (raw) => {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const readTranscriptionText = (result) => {
+  if (typeof result === "object" && result !== null && "text" in result) {
+    const { text } = result;
+    return typeof text === "string" ? text : "";
+  }
+  return "";
+};
+const readSynthesisAudio = (result) => {
+  if (result instanceof Uint8Array || result instanceof ReadableStream) {
+    return result;
+  }
+  if (result instanceof Response && result.body) {
+    return result.body;
+  }
+  if (typeof result === "object" && result !== null && "audio" in result) {
+    const { audio } = result;
+    if (typeof audio === "string") {
+      return fromBase64(audio);
+    }
+    if (audio instanceof ReadableStream || audio instanceof Uint8Array) {
+      return audio;
+    }
+  }
+  return new Uint8Array(0);
+};
+
+export { parseIdentity, pcmToWav, readSynthesisAudio, readTranscriptionText, runVoiceTurn, toByteIterable };

package/dist/packem_shared/sandboxComponent-DR3pTwBL.mjs

@@ -0,0 +1,194 @@
+import { LunoraError } from '@lunora/errors';
+import { initLunora } from '@lunora/server';
+import { v } from '@lunora/values';
+import { t as toBase64 } from './base64-BVwtgRJV.mjs';
+
+const { internalAction } = initLunora.dataModel().create();
+const sandboxScrapeDocument = () => globalThis.document?.documentElement?.outerHTML ?? "";
+const MAX_FS_BYTES = 1e6;
+const MAX_LS_PAGES = 20;
+const fsEncoder = new TextEncoder();
+const runBrowserOp = async (browser, request) => {
+  const url = request.url ?? "";
+  switch (request.op) {
+    case "content": {
+      return browser.content(url);
+    }
+    case "pdf": {
+      return { data: toBase64(await browser.pdf(url)), encoding: "base64", mediaType: "application/pdf" };
+    }
+    case "scrape": {
+      return browser.scrape(url, sandboxScrapeDocument);
+    }
+    case "screenshot": {
+      const bytes = await browser.screenshot(url, {
+        ...request.fullPage === void 0 ? {} : { fullPage: request.fullPage },
+        ...request.type === void 0 ? {} : { type: request.type }
+      });
+      return { data: toBase64(bytes), encoding: "base64", mediaType: request.type === "jpeg" ? "image/jpeg" : "image/png" };
+    }
+    default: {
+      throw new LunoraError("INTERNAL", `@lunora/agent: sandbox browser op "${request.op}" is not supported`);
+    }
+  }
+};
+const runContainerOp = async (accessor, request) => {
+  const handle = accessor.any();
+  if (request.op === "exec") {
+    const response = await handle.fetch("/exec", {
+      body: JSON.stringify({ args: request.args ?? [], command: request.command ?? "" }),
+      headers: { "content-type": "application/json" },
+      method: "POST"
+    });
+    return response.text();
+  }
+  if (request.op === "fetch") {
+    const response = await handle.fetch(request.path ?? "/", {
+      ...request.body === void 0 ? {} : { body: request.body },
+      method: request.method ?? "GET"
+    });
+    return response.text();
+  }
+  throw new LunoraError("INTERNAL", `@lunora/agent: sandbox container op "${request.op}" is not supported`);
+};
+const trimSlashes = (value) => {
+  let start = 0;
+  let end = value.length;
+  while (start < end && value[start] === "/") {
+    start += 1;
+  }
+  while (end > start && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(start, end);
+};
+const resolveFsKey = (root, path) => {
+  const base = trimSlashes(root);
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      if (segments.length === 0) {
+        throw new LunoraError("BAD_REQUEST", "@lunora/agent: fs path escapes the sandbox root");
+      }
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  const relative = segments.join("/");
+  return base && relative ? `${base}/${relative}` : base || relative;
+};
+const listFsEntries = async (bucket, key, base) => {
+  const prefix = key.length > 0 ? `${key}/` : "";
+  const strip = base.length > 0 ? base.length + 1 : 0;
+  const entries = [];
+  let cursor;
+  for (let page = 0; page < MAX_LS_PAGES; page += 1) {
+    const result = await bucket.list({ prefix, ...cursor === void 0 ? {} : { cursor } });
+    for (const object of result.objects) {
+      entries.push(object.key.slice(strip));
+    }
+    if (!result.truncated || result.cursor === void 0) {
+      return { entries, truncated: false };
+    }
+    cursor = result.cursor;
+  }
+  return { entries, truncated: true };
+};
+const runFsOp = async (bucket, root, request) => {
+  const base = trimSlashes(root);
+  const key = resolveFsKey(root, request.path ?? "");
+  switch (request.op) {
+    case "ls": {
+      const { entries, truncated } = await listFsEntries(bucket, key, base);
+      return truncated ? { entries, truncated: true } : { entries };
+    }
+    case "read": {
+      const head = await bucket.head(key);
+      if (head && head.size > MAX_FS_BYTES) {
+        throw new LunoraError(
+          "BAD_REQUEST",
+          `@lunora/agent: fs read: "${request.path ?? ""}" is ${String(head.size)} bytes (max ${String(MAX_FS_BYTES)})`
+        );
+      }
+      const object = await bucket.get(key);
+      if (!object) {
+        throw new LunoraError("NOT_FOUND", `@lunora/agent: fs read: no file at "${request.path ?? ""}"`);
+      }
+      return object.text();
+    }
+    case "rm": {
+      await bucket.delete(key);
+      return { path: request.path ?? "", removed: true };
+    }
+    case "stat": {
+      const head = await bucket.head(key);
+      return head ? { exists: true, size: head.size } : { exists: false };
+    }
+    case "write": {
+      const content = request.content ?? "";
+      const bytes = fsEncoder.encode(content).length;
+      if (bytes > MAX_FS_BYTES) {
+        throw new LunoraError("BAD_REQUEST", `@lunora/agent: fs write: ${String(bytes)} bytes exceeds the max (${String(MAX_FS_BYTES)})`);
+      }
+      await bucket.put(key, content);
+      return { bytes, path: request.path ?? "", wrote: true };
+    }
+    default: {
+      throw new LunoraError("INTERNAL", `@lunora/agent: sandbox fs op "${request.op}" is not supported`);
+    }
+  }
+};
+const sandboxComponent = () => {
+  const invoke = internalAction.input({
+    args: v.optional(v.array(v.string())),
+    body: v.optional(v.string()),
+    bucket: v.optional(v.string()),
+    command: v.optional(v.string()),
+    content: v.optional(v.string()),
+    fullPage: v.optional(v.boolean()),
+    kind: v.union(v.literal("browser"), v.literal("container"), v.literal("fs")),
+    method: v.optional(v.string()),
+    name: v.optional(v.string()),
+    op: v.string(),
+    path: v.optional(v.string()),
+    root: v.optional(v.string()),
+    selector: v.optional(v.string()),
+    type: v.optional(v.string()),
+    url: v.optional(v.string())
+  }).action(async ({ args, ctx: context }) => {
+    const surface = context;
+    const request = args;
+    if (request.kind === "browser") {
+      if (!surface.browser) {
+        throw new LunoraError("INTERNAL", "@lunora/agent: sandbox browser op needs `ctx.browser` — install @lunora/browser and run codegen");
+      }
+      return runBrowserOp(surface.browser, request);
+    }
+    if (request.kind === "fs") {
+      const bucket = surface.env?.[request.bucket ?? ""];
+      if (!bucket || typeof bucket.get !== "function") {
+        throw new LunoraError(
+          "INTERNAL",
+          `@lunora/agent: sandbox fs op found no R2 bucket "${request.bucket ?? ""}" on env — declare the r2_bucket binding in wrangler.jsonc and run codegen`
+        );
+      }
+      return runFsOp(bucket, request.root ?? "", request);
+    }
+    const name = request.name ?? "";
+    const accessor = surface.containers?.[name];
+    if (!accessor) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: sandbox container op found no ctx.containers["${name}"] — declare the container in lunora/containers.ts and run codegen`
+      );
+    }
+    return runContainerOp(accessor, request);
+  });
+  return { invoke };
+};
+
+export { resolveFsKey, runFsOp, sandboxComponent };

package/dist/packem_shared/sentryTelemetry-A4F5ndh9.mjs

@@ -0,0 +1,36 @@
+import { r as readField, t as toolInputOf } from './common-DQXayow6.mjs';
+
+const stringOr = (value, fallback) => typeof value === "string" && value.length > 0 ? value : fallback;
+const sentryTelemetry = (options) => {
+  const { functionId, recordInputs = false, Sentry: sentry } = options;
+  return {
+    executeLanguageModelCall: (options_) => {
+      const attributes = {
+        "gen_ai.operation.name": stringOr(functionId, "language_model_call"),
+        "gen_ai.request.model": readField(options_, "modelId"),
+        "gen_ai.system": readField(options_, "provider")
+      };
+      if (recordInputs) {
+        attributes["gen_ai.prompt"] = readField(options_, "messages");
+      }
+      return sentry.startSpan({ attributes, name: stringOr(functionId, "language_model_call"), op: "gen_ai.generate" }, () => options_.execute());
+    },
+    executeTool: (options_) => {
+      const toolName = readField(readField(options_, "toolCall"), "toolName");
+      const attributes = {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.call.id": readField(options_, "toolCallId"),
+        "gen_ai.tool.name": toolName
+      };
+      if (recordInputs) {
+        attributes["gen_ai.tool.input"] = toolInputOf(options_);
+      }
+      return sentry.startSpan({ attributes, name: `execute_tool ${stringOr(toolName, "tool")}`, op: "gen_ai.execute_tool" }, () => options_.execute());
+    },
+    onError: (error) => {
+      sentry.captureException(error);
+    }
+  };
+};
+
+export { sentryTelemetry };