@lunora/ai 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/packem_shared/{defineRag-DgVXmNGw.mjs → defineRag-CQ3pnKUh.mjs}

@@ -113,6 +113,20 @@ const modelIdOf = (model) => {
   const id = model.modelId;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 };
+const embedCostOf = (providerMetadata) => {
+  if (typeof providerMetadata !== "object" || providerMetadata === null) {
+    return void 0;
+  }
+  for (const bag of Object.values(providerMetadata)) {
+    if (typeof bag === "object" && bag !== null) {
+      const { cost } = bag;
+      if (typeof cost === "number" && Number.isFinite(cost)) {
+        return cost;
+      }
+    }
+  }
+  return void 0;
+};
 const defineRag = (config) => {
   if (typeof config.index !== "string" || config.index.length === 0) {
     throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `index` must be a non-empty Vectorize index name");
@@ -151,15 +165,25 @@ const defineRag = (config) => {
     const embedText = async (text) => {
       model ??= resolveEmbeddingModel(config.embeddingModel, context.ai);
       const resolvedModel = model;
-      const run = async () => {
-        const { embedding } = await embed({ model: resolvedModel, value: text });
+      const run = async (span) => {
+        const { embedding, providerMetadata, usage } = await embed({ model: resolvedModel, value: text });
+        if (span !== void 0) {
+          const inputTokens = usage.tokens;
+          if (typeof inputTokens === "number" && Number.isFinite(inputTokens)) {
+            span.setAttribute("gen_ai.usage.input_tokens", inputTokens);
+          }
+          const cost = embedCostOf(providerMetadata);
+          if (cost !== void 0) {
+            span.setAttribute("gen_ai.usage.cost", cost);
+          }
+        }
         return embedding;
       };
       if (tracer === void 0) {
         return run();
       }
       const modelId = modelIdOf(resolvedModel);
-      return tracer("ai.embed", run, {
+      return tracer("ai.embed", (_trace, span) => run(span), {
         "gen_ai.operation.name": "embeddings",
         ...modelId === void 0 ? {} : { "gen_ai.request.model": modelId }
       });

package/dist/rag/index.d.mts

@@ -112,11 +112,15 @@ interface RagContext {
   /**
    * Optional `ctx.trace` span factory — an `ActionCtx`'s `ctx.trace` satisfies
    * it structurally. When present, `defineRag` wraps each embedding-model
-   * call in a `generation` span (`gen_ai.operation.name: "embeddings"` +
-   * `gen_ai.request.model`), so the embed shows up on the trace waterfall like
-   * any other instrumented sub-operation. `unknown` on purpose — the same
-   * decoupling rationale as `auth`: `defineRag` narrows it to a callable and
-   * runs embeds untraced when it is absent (a hand-built context / test).
+   * call in a `generation` span carrying `gen_ai.operation.name: "embeddings"`
+   * and `gen_ai.request.model` up front, plus — attached post-hoc through the
+   * span handle the tracer hands the body — `gen_ai.usage.input_tokens` (from
+   * the embed result's token usage) and `gen_ai.usage.cost` (probed from the
+   * embed result's provider metadata, e.g. AI Gateway) when those are present.
+   * So the embed shows up on the trace waterfall with its usage like any other
+   * instrumented model call. `unknown` on purpose — the same decoupling
+   * rationale as `auth`: `defineRag` narrows it to a callable and runs embeds
+   * untraced when it is absent (a hand-built context / test).
    */
   trace?: unknown;
   vectors: RagVectors;

package/dist/rag/index.d.ts

@@ -112,11 +112,15 @@ interface RagContext {
   /**
    * Optional `ctx.trace` span factory — an `ActionCtx`'s `ctx.trace` satisfies
    * it structurally. When present, `defineRag` wraps each embedding-model
-   * call in a `generation` span (`gen_ai.operation.name: "embeddings"` +
-   * `gen_ai.request.model`), so the embed shows up on the trace waterfall like
-   * any other instrumented sub-operation. `unknown` on purpose — the same
-   * decoupling rationale as `auth`: `defineRag` narrows it to a callable and
-   * runs embeds untraced when it is absent (a hand-built context / test).
+   * call in a `generation` span carrying `gen_ai.operation.name: "embeddings"`
+   * and `gen_ai.request.model` up front, plus — attached post-hoc through the
+   * span handle the tracer hands the body — `gen_ai.usage.input_tokens` (from
+   * the embed result's token usage) and `gen_ai.usage.cost` (probed from the
+   * embed result's provider metadata, e.g. AI Gateway) when those are present.
+   * So the embed shows up on the trace waterfall with its usage like any other
+   * instrumented model call. `unknown` on purpose — the same decoupling
+   * rationale as `auth`: `defineRag` narrows it to a callable and runs embeds
+   * untraced when it is absent (a hand-built context / test).
    */
   trace?: unknown;
   vectors: RagVectors;

package/dist/rag/index.mjs

@@ -1,5 +1,5 @@
 export { default as fixedWindowChunks } from '../packem_shared/fixedWindowChunks-J-WfQDw9.mjs';
-export { default as defineRag } from '../packem_shared/defineRag-DgVXmNGw.mjs';
+export { default as defineRag } from '../packem_shared/defineRag-CQ3pnKUh.mjs';
 export { contentHash, guessMimeTypeFromExtension } from '../packem_shared/contentHash-Cgz5KRGD.mjs';
 export { default as hybridRank } from '../packem_shared/hybridRank-DPC9c2ON.mjs';
 export { default as bm25LexicalStore } from '../packem_shared/bm25LexicalStore-BQzWLMqX.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/ai",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.21",
   "description": "Workers AI helper for Lunora: provider-agnostic AI SDK access from functions, Workers AI by default",
   "keywords": [
     "ai",