@lunora/agent 1.0.0-alpha.9 → 1.0.0-alpha.91

package/dist/packem_shared/graph-component-Bbaxxymp.mjs

@@ -1,217 +0,0 @@
-import { defineTable, initLunora } from '@lunora/server';
-import { v } from '@lunora/values';
-
-const AGENT_EXTENSION_KEY = "agent";
-const asInternal = (function_) => {
-  return { ...function_, visibility: "internal" };
-};
-const definedColumns = (columns) => {
-  const result = {};
-  for (const [key, value] of Object.entries(columns)) {
-    if (value !== void 0) {
-      result[key] = value;
-    }
-  }
-  return result;
-};
-
-const ENTITIES_BARE_TABLE = "entities";
-const EDGES_BARE_TABLE = "edges";
-const ENTITIES_TABLE = `${AGENT_EXTENSION_KEY}_${ENTITIES_BARE_TABLE}`;
-const EDGES_TABLE = `${AGENT_EXTENSION_KEY}_${EDGES_BARE_TABLE}`;
-const graphTables = {
-  /**
-   * Graph-memory nodes — one per normalized entity name per owner. `weight` is
-   * salience (last-write-wins, absolute set → replay-idempotent),
-   * `firstMessageKey` is provenance.
-   */
-  [ENTITIES_BARE_TABLE]: defineTable({
-    createdAt: v.number(),
-    firstMessageKey: v.optional(v.string()),
-    /** Normalized (trim/collapse/lowercase) — the per-owner dedup key. */
-    name: v.string(),
-    owner: v.string(),
-    type: v.optional(v.string()),
-    updatedAt: v.number(),
-    weight: v.optional(v.number())
-  }).index("byOwnerName", ["owner", "name"], { unique: true }).index("byOwnerUpdatedAt", ["owner", "updatedAt"]).public(),
-  /**
-   * Graph-memory edges — directed triples storing the normalized endpoint
-   * NAMES (no join on write), owner-scoped like the nodes. `weight` is
-   * confidence (last-write-wins), `messageKey` is provenance. Traversal is
-   * bidirectional, so both endpoints are indexed.
-   */
-  [EDGES_BARE_TABLE]: defineTable({
-    createdAt: v.number(),
-    dstName: v.string(),
-    label: v.string(),
-    messageKey: v.string(),
-    owner: v.string(),
-    srcName: v.string(),
-    updatedAt: v.number(),
-    weight: v.optional(v.number())
-  }).index("byOwnerSrc", ["owner", "srcName"]).index("byOwnerDst", ["owner", "dstName"]).index("byTriple", ["owner", "srcName", "label", "dstName"], { unique: true }).public()
-};
-const GRAPH_ARRAY_CAP = 64;
-const DEFAULT_GRAPH_DEPTH = 2;
-const DEFAULT_GRAPH_MAX_SEEDS = 4;
-const DEFAULT_GRAPH_FAN_OUT = 8;
-const DEFAULT_GRAPH_MAX_NODES = 32;
-const GRAPH_SEED_SCAN_CAP = 500;
-const WHITESPACE_RUN = /\s+/gu;
-const NON_WORD = /[^\p{L}\p{N}]+/u;
-const normalizeEntityName = (name) => name.trim().replaceAll(WHITESPACE_RUN, " ").toLowerCase();
-const tokenizeQuery = (text) => text.toLowerCase().split(NON_WORD).filter((token) => token.length >= 2);
-const toGraphEdge = (row) => {
-  return {
-    dstName: row["dstName"],
-    label: row["label"],
-    srcName: row["srcName"],
-    weight: row["weight"] ?? 1
-  };
-};
-const compareEdgesByWeight = (a, b) => b.weight - a.weight || a.label.localeCompare(b.label) || a.srcName.localeCompare(b.srcName) || a.dstName.localeCompare(b.dstName);
-const matchesSeed = (entityName, tokens) => tokens.some((token) => entityName.includes(token) || token.includes(entityName));
-const renderTriples = (edges) => edges.map((edge) => `- ${edge.srcName} —[${edge.label}]→ ${edge.dstName}`).toSorted((a, b) => a.localeCompare(b)).join("\n");
-const edgeKey = (edge) => `${edge.srcName}\0${edge.label}\0${edge.dstName}`;
-const addEdge = (edge, from, bounds, accumulator) => {
-  const key = edgeKey(edge);
-  if (!accumulator.collectedKeys.has(key)) {
-    accumulator.collectedKeys.add(key);
-    accumulator.collected.push(edge);
-  }
-  const neighbor = edge.srcName === from ? edge.dstName : edge.srcName;
-  if (!accumulator.seen.has(neighbor) && accumulator.seen.size < bounds.maxNodes) {
-    accumulator.seen.add(neighbor);
-    accumulator.next.push(neighbor);
-  }
-};
-const traverseGraph = async (edgesFrom, seeds, bounds) => {
-  const accumulator = { collected: [], collectedKeys: /* @__PURE__ */ new Set(), next: [], seen: new Set(seeds) };
-  let frontier = seeds.slice(0, bounds.maxNodes);
-  for (let depth = 0; depth < bounds.depth && frontier.length > 0; depth += 1) {
-    accumulator.next = [];
-    for (const node of frontier) {
-      const nodeEdges = await edgesFrom(node);
-      const incident = nodeEdges.toSorted(compareEdgesByWeight).slice(0, bounds.fanOut);
-      for (const edge of incident) {
-        addEdge(edge, node, bounds, accumulator);
-      }
-    }
-    frontier = accumulator.next;
-  }
-  return accumulator.collected;
-};
-const { mutation, query } = initLunora.dataModel().create();
-const graphComponent = () => {
-  const agentGraphUpsert = mutation.input({
-    entities: v.array(v.object({ name: v.string(), type: v.optional(v.string()) })),
-    messageKey: v.string(),
-    owner: v.string(),
-    relations: v.array(v.object({ confidence: v.optional(v.number()), dst: v.string(), label: v.string(), src: v.string() }))
-  }).mutation(async ({ args, ctx: context }) => {
-    const now = Date.now();
-    const upsertEntity = async (rawName, type) => {
-      const name = normalizeEntityName(rawName);
-      if (name.length === 0) {
-        return void 0;
-      }
-      const existing = await context.db.query(ENTITIES_TABLE).withIndex("byOwnerName", (q) => q.eq("owner", args.owner).eq("name", name)).first();
-      if (existing) {
-        if (type !== void 0 && existing["type"] === void 0) {
-          await context.db.patch(existing["_id"], { type, updatedAt: now });
-        }
-        return name;
-      }
-      await context.db.insert(ENTITIES_TABLE, {
-        createdAt: now,
-        name,
-        owner: args.owner,
-        updatedAt: now,
-        weight: 1,
-        ...definedColumns({ firstMessageKey: args.messageKey, type })
-      });
-      return name;
-    };
-    const upsertRelation = async (relation) => {
-      const sourceName = normalizeEntityName(relation.src);
-      const destinationName = normalizeEntityName(relation.dst);
-      const label = normalizeEntityName(relation.label);
-      if (sourceName.length === 0 || destinationName.length === 0 || label.length === 0 || sourceName === destinationName) {
-        return false;
-      }
-      await upsertEntity(sourceName);
-      await upsertEntity(destinationName);
-      const confidence = relation.confidence ?? 1;
-      const existing = await context.db.query(EDGES_TABLE).withIndex("byTriple", (q) => q.eq("owner", args.owner).eq("srcName", sourceName).eq("label", label).eq("dstName", destinationName)).first();
-      if (existing) {
-        const priorWeight = existing["weight"] ?? 1;
-        await context.db.patch(existing["_id"], { updatedAt: now, weight: Math.max(priorWeight, confidence) });
-      } else {
-        await context.db.insert(EDGES_TABLE, {
-          createdAt: now,
-          dstName: destinationName,
-          label,
-          messageKey: args.messageKey,
-          owner: args.owner,
-          srcName: sourceName,
-          updatedAt: now,
-          weight: confidence
-        });
-      }
-      return true;
-    };
-    let entities = 0;
-    for (const entity of args.entities.slice(0, GRAPH_ARRAY_CAP)) {
-      if (await upsertEntity(entity.name, entity.type) !== void 0) {
-        entities += 1;
-      }
-    }
-    let relations = 0;
-    for (const relation of args.relations.slice(0, GRAPH_ARRAY_CAP)) {
-      if (await upsertRelation(relation)) {
-        relations += 1;
-      }
-    }
-    return { entities, relations };
-  });
-  const agentGraphTraverse = query.input({
-    depth: v.optional(v.number()),
-    fanOut: v.optional(v.number()),
-    maxNodes: v.optional(v.number()),
-    maxSeeds: v.optional(v.number()),
-    owner: v.string(),
-    query: v.string()
-  }).query(async ({ args, ctx: context }) => {
-    const tokens = tokenizeQuery(args.query);
-    if (tokens.length === 0) {
-      return { context: "" };
-    }
-    const ownerEntities = await context.db.query(ENTITIES_TABLE).withIndex("byOwnerUpdatedAt", (q) => q.eq("owner", args.owner)).order("desc").take(GRAPH_SEED_SCAN_CAP);
-    const seeds = ownerEntities.filter((row) => matchesSeed(row["name"], tokens)).toSorted(
-      (a, b) => (b["weight"] ?? 1) - (a["weight"] ?? 1) || a["name"].localeCompare(b["name"])
-    ).slice(0, args.maxSeeds ?? DEFAULT_GRAPH_MAX_SEEDS).map((row) => row["name"]);
-    if (seeds.length === 0) {
-      return { context: "" };
-    }
-    const edgesFrom = async (node) => {
-      const [outgoing, incoming] = await Promise.all([
-        context.db.query(EDGES_TABLE).withIndex("byOwnerSrc", (q) => q.eq("owner", args.owner).eq("srcName", node)).collect(),
-        context.db.query(EDGES_TABLE).withIndex("byOwnerDst", (q) => q.eq("owner", args.owner).eq("dstName", node)).collect()
-      ]);
-      return [...outgoing, ...incoming].map((row) => toGraphEdge(row));
-    };
-    const edges = await traverseGraph(edgesFrom, seeds, {
-      depth: args.depth ?? DEFAULT_GRAPH_DEPTH,
-      fanOut: args.fanOut ?? DEFAULT_GRAPH_FAN_OUT,
-      maxNodes: args.maxNodes ?? DEFAULT_GRAPH_MAX_NODES
-    });
-    return { context: renderTriples(edges) };
-  });
-  return {
-    agentGraphTraverse: asInternal(agentGraphTraverse),
-    agentGraphUpsert: asInternal(agentGraphUpsert)
-  };
-};
-
-export { AGENT_EXTENSION_KEY as A, asInternal as a, graphComponent as b, definedColumns as d, graphTables as g, normalizeEntityName as n };

package/dist/packem_shared/memory-D4FPcBsX.mjs

@@ -1,12 +0,0 @@
-const isInjectedMemorySource = (memory) => memory.kind === "graph" || memory.kind === "episodic" || memory.mode !== "agentic";
-const resolveInjectedSources = (agent) => {
-  if (agent.memorySources) {
-    return agent.memorySources;
-  }
-  return agent.memory && isInjectedMemorySource(agent.memory) ? [{ key: "default", ...agent.memory }] : [];
-};
-const firstGraphSource = (agent) => resolveInjectedSources(agent).find((source) => source.kind === "graph");
-const firstEpisodicSource = (agent) => resolveInjectedSources(agent).find((source) => source.kind === "episodic");
-const memoryStepName = (base, key) => key === "default" ? base : `${base}:${key}`;
-
-export { firstEpisodicSource as a, firstGraphSource as f, isInjectedMemorySource as i, memoryStepName as m, resolveInjectedSources as r };

package/dist/packem_shared/normalizeEntityName-BouctxLC.mjs

@@ -1,3 +0,0 @@
-import '@lunora/server';
-import '@lunora/values';
-export { b as graphComponent, g as graphTables, n as normalizeEntityName } from './graph-component-Bbaxxymp.mjs';

package/dist/packem_shared/otlpTelemetry-CKgmWVLg.mjs

@@ -1,170 +0,0 @@
-import { s as summarizeUsage, r as readField, e as summarizeGatewayTelemetry, c as contentText, t as toolInputOf, a as toolNameOf } from './common-DQXayow6.mjs';
-
-const otlpUnixNano = (ms) => `${String(Math.round(ms))}000000`;
-const otlpRandomHex = (bytes) => {
-  const buffer = new Uint8Array(bytes);
-  crypto.getRandomValues(buffer);
-  let hex = "";
-  for (const byte of buffer) {
-    hex += byte.toString(16).padStart(2, "0");
-  }
-  return hex;
-};
-const encodeAttribute = (key, value) => {
-  if (typeof value === "boolean") {
-    return { key, value: { boolValue: value } };
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      return { key, value: { stringValue: String(value) } };
-    }
-    return Number.isSafeInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
-  }
-  return { key, value: { stringValue: value } };
-};
-const mergeHeaders = (defaults, overrides, token) => {
-  const merged = {};
-  const seen = /* @__PURE__ */ new Map();
-  const put = (name, value) => {
-    const lower = name.toLowerCase();
-    const existing = seen.get(lower);
-    if (existing === void 0) {
-      seen.set(lower, name);
-      merged[name] = value;
-    } else {
-      merged[existing] = value;
-    }
-  };
-  for (const [name, value] of Object.entries(defaults)) {
-    put(name, value);
-  }
-  for (const [name, value] of Object.entries(overrides ?? {})) {
-    put(name, value);
-  }
-  if (token !== void 0 && token.length > 0) {
-    put("authorization", `Bearer ${token}`);
-  }
-  return merged;
-};
-const wrapResourceSpans = (span, scopeName, serviceName) => {
-  return {
-    resourceSpans: [
-      {
-        resource: { attributes: [encodeAttribute("service.name", serviceName)] },
-        scopeSpans: [{ scope: { name: scopeName }, spans: [span] }]
-      }
-    ]
-  };
-};
-
-const pushAttribute = (attributes, key, value) => {
-  if (value === void 0 || value === null) {
-    return;
-  }
-  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-    attributes.push(encodeAttribute(key, value));
-    return;
-  }
-  attributes.push(encodeAttribute(key, JSON.stringify(value)));
-};
-const observeSettled = (promise, onSettle) => {
-  const run = async () => {
-    let result;
-    try {
-      result = await promise;
-    } catch (error) {
-      onSettle(false, error instanceof Error ? error.message : String(error), void 0);
-      return;
-    }
-    onSettle(true, void 0, result);
-  };
-  run().catch(() => void 0);
-};
-const otlpTelemetry = (options) => {
-  const { conversationId, endpoint, headers, recordInputs = false, recordOutputs = false, token, traceId: fixedTraceId, waitUntil } = options;
-  const serviceName = options.serviceName ?? "lunora";
-  let base = endpoint;
-  while (base.endsWith("/")) {
-    base = base.slice(0, -1);
-  }
-  const tracesUrl = `${base}/v1/traces`;
-  const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers, token);
-  const emitSpan = (name, startTs, ok, message, attributes) => {
-    const span = {
-      attributes,
-      endTimeUnixNano: otlpUnixNano(Date.now()),
-      // SPAN_KIND_INTERNAL — matches the runtime's `ctx.trace` spans.
-      kind: 1,
-      name,
-      spanId: otlpRandomHex(8),
-      startTimeUnixNano: otlpUnixNano(startTs),
-      // STATUS_CODE_OK (1) / STATUS_CODE_ERROR (2).
-      status: ok ? { code: 1 } : { code: 2, message: message ?? "" },
-      traceId: fixedTraceId ?? otlpRandomHex(16)
-    };
-    try {
-      const sent = fetch(tracesUrl, {
-        body: JSON.stringify(wrapResourceSpans(span, "@lunora/agent", serviceName)),
-        headers: mergedHeaders,
-        method: "POST"
-      }).catch(() => {
-      });
-      waitUntil?.(sent);
-    } catch {
-    }
-  };
-  return {
-    executeLanguageModelCall: (options_) => {
-      const startTs = Date.now();
-      const modelId = readField(options_, "modelId");
-      const promise = options_.execute();
-      const emit = (ok, message, result) => {
-        const attributes = [];
-        pushAttribute(attributes, "gen_ai.operation.name", "chat");
-        pushAttribute(attributes, "gen_ai.request.model", modelId);
-        pushAttribute(attributes, "gen_ai.system", readField(options_, "provider"));
-        pushAttribute(attributes, "gen_ai.conversation.id", conversationId);
-        const usage = summarizeUsage(readField(result, "usage"));
-        if (usage) {
-          pushAttribute(attributes, "gen_ai.usage.input_tokens", usage.inputTokens);
-          pushAttribute(attributes, "gen_ai.usage.output_tokens", usage.outputTokens);
-          pushAttribute(attributes, "gen_ai.usage.total_tokens", usage.totalTokens);
-        }
-        const gateway = summarizeGatewayTelemetry(result);
-        if (gateway) {
-          pushAttribute(attributes, "gen_ai.usage.cost", gateway.cost);
-          pushAttribute(attributes, "gen_ai.response.cached", gateway.cached);
-          pushAttribute(attributes, "cf.aig.log_id", gateway.logId);
-        }
-        if (recordInputs) {
-          pushAttribute(attributes, "gen_ai.prompt", readField(options_, "messages"));
-        }
-        if (recordOutputs) {
-          pushAttribute(attributes, "gen_ai.completion", contentText(readField(result, "content")));
-        }
-        emitSpan(typeof modelId === "string" ? `chat ${modelId}` : "language_model_call", startTs, ok, message, attributes);
-      };
-      observeSettled(promise, emit);
-      return promise;
-    },
-    executeTool: (options_) => {
-      const startTs = Date.now();
-      const toolName = toolNameOf(options_);
-      const promise = options_.execute();
-      const emit = (ok, message) => {
-        const attributes = [];
-        pushAttribute(attributes, "gen_ai.operation.name", "execute_tool");
-        pushAttribute(attributes, "gen_ai.tool.name", toolName);
-        pushAttribute(attributes, "gen_ai.tool.call.id", readField(options_, "toolCallId"));
-        if (recordInputs) {
-          pushAttribute(attributes, "gen_ai.tool.input", toolInputOf(options_));
-        }
-        emitSpan(typeof toolName === "string" ? `execute_tool ${toolName}` : "execute_tool", startTs, ok, message, attributes);
-      };
-      observeSettled(promise, emit);
-      return promise;
-    }
-  };
-};
-
-export { otlpTelemetry };