@lunora/agent 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/createAgentGenerate-BQv9YJ01.mjs

@@ -0,0 +1,192 @@
+import { createAi } from '@lunora/ai';
+import { LunoraError } from '@lunora/errors';
+import { jsonSchema, generateText, streamText, Output, tool } from 'ai';
+
+const toAgentUsage = (usage) => {
+  if (!usage) {
+    return void 0;
+  }
+  const result = {};
+  if (usage.inputTokens !== void 0) {
+    result.inputTokens = usage.inputTokens;
+  }
+  if (usage.outputTokens !== void 0) {
+    result.outputTokens = usage.outputTokens;
+  }
+  if (usage.totalTokens !== void 0) {
+    result.totalTokens = usage.totalTokens;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+};
+const mapToolCalls = (calls) => calls.map((call) => {
+  return { id: call.toolCallId, input: call.input, name: call.toolName };
+});
+const resolveAgentModel = (model, env) => {
+  if (typeof model === "function") {
+    return model(env);
+  }
+  if (typeof model === "string") {
+    const binding = env["AI"];
+    if (!binding) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: the agent model "${model}" is a Workers AI id but there is no \`AI\` binding on the workflow env — declare the ai binding in wrangler.jsonc`
+      );
+    }
+    return createAi({ binding }).model(model);
+  }
+  return model;
+};
+const prepareAgentTurn = (agent, env) => {
+  const defaultModel = resolveAgentModel(agent.model, env);
+  const tools = {};
+  for (const [name, definition] of Object.entries(agent.tools ?? {})) {
+    tools[name] = tool({ description: definition.description, inputSchema: definition.inputSchema });
+  }
+  const output = agent.output === void 0 ? void 0 : Output.object({ schema: agent.output });
+  const staticSettings = {
+    ...agent.temperature === void 0 ? {} : { temperature: agent.temperature },
+    ...agent.maxOutputTokens === void 0 ? {} : { maxOutputTokens: agent.maxOutputTokens },
+    ...agent.telemetry === void 0 ? {} : { telemetry: agent.telemetry },
+    ...agent.repairToolCall === void 0 ? {} : { experimental_repairToolCall: agent.repairToolCall }
+  };
+  return { defaultModel, output, staticSettings, tools };
+};
+const buildTurnRequest = (base, { activeTools, messages, model, signal, toolChoice }) => {
+  const { defaultModel, output, staticSettings, tools } = base;
+  const exposed = activeTools === void 0 ? tools : Object.fromEntries(Object.entries(tools).filter(([name]) => activeTools.includes(name)));
+  return {
+    messages,
+    model: model ?? defaultModel,
+    ...staticSettings,
+    ...Object.keys(exposed).length > 0 ? { tools: exposed } : {},
+    ...toolChoice === void 0 ? {} : { toolChoice },
+    ...output === void 0 ? {} : { output },
+    // A voice barge-in aborts the turn mid-stream; the durable loop never
+    // sets it. Harmless on `generateText` (which accepts the same option).
+    ...signal === void 0 ? {} : { abortSignal: signal }
+  };
+};
+const createAgentGenerate = (agent, env) => {
+  const base = prepareAgentTurn(agent, env);
+  return async (options) => {
+    const result = await generateText(buildTurnRequest(base, options));
+    const usage = toAgentUsage(result.usage);
+    return {
+      text: result.text,
+      toolCalls: mapToolCalls(result.toolCalls),
+      ...usage === void 0 ? {} : { usage },
+      ...base.output === void 0 ? {} : { output: result.output }
+    };
+  };
+};
+const createStreamGenerate = (agent, env) => {
+  const base = prepareAgentTurn(agent, env);
+  return async (options, onDelta) => {
+    const result = streamText(buildTurnRequest(base, options));
+    let streamed = "";
+    try {
+      for await (const delta of result.textStream) {
+        streamed += delta;
+        onDelta(delta);
+      }
+    } catch (error) {
+      if (options.signal?.aborted) {
+        return { text: streamed, toolCalls: [] };
+      }
+      throw error;
+    }
+    const [text, toolCalls, usage, output] = await Promise.all([
+      result.text,
+      result.toolCalls,
+      result.usage,
+      base.output === void 0 ? Promise.resolve(void 0) : result.output
+    ]);
+    const agentUsage = toAgentUsage(usage);
+    return {
+      text,
+      toolCalls: mapToolCalls(toolCalls),
+      ...agentUsage === void 0 ? {} : { usage: agentUsage },
+      ...base.output === void 0 ? {} : { output }
+    };
+  };
+};
+const GRAPH_EXTRACTION_SCHEMA = jsonSchema({
+  additionalProperties: false,
+  properties: {
+    entities: {
+      description: "The distinct entities (people, orgs, places, things, concepts) named in the exchange.",
+      items: {
+        additionalProperties: false,
+        properties: {
+          name: { description: "The entity's canonical name.", type: "string" },
+          type: { description: "An optional coarse type, e.g. person, org, place, product.", type: "string" }
+        },
+        required: ["name"],
+        type: "object"
+      },
+      type: "array"
+    },
+    relations: {
+      description: "The directed relationships between the entities, as (src)-[label]->(dst) triples.",
+      items: {
+        additionalProperties: false,
+        properties: {
+          confidence: { description: "Confidence in the relation, 0..1.", type: "number" },
+          dst: { description: "The destination entity name (must appear in `entities`).", type: "string" },
+          label: { description: "The relationship, a short snake_case verb phrase, e.g. works_at.", type: "string" },
+          src: { description: "The source entity name (must appear in `entities`).", type: "string" }
+        },
+        required: ["src", "dst", "label"],
+        type: "object"
+      },
+      type: "array"
+    }
+  },
+  required: ["entities", "relations"],
+  type: "object"
+});
+const buildExtractionPrompt = (userInput, assistantText) => [
+  "Extract a knowledge graph of the durable facts stated in the following exchange.",
+  "Return the distinct entities and the directed relationships between them.",
+  "Only include facts actually stated — do not invent entities or relations. Prefer few, high-signal triples.",
+  "",
+  `User: ${userInput}`,
+  "",
+  `Assistant: ${assistantText}`
+].join("\n");
+const createGraphExtract = () => async ({ assistantText, env, model, userInput }) => {
+  const { output } = await generateText({
+    model: resolveAgentModel(model, env),
+    output: Output.object({ schema: GRAPH_EXTRACTION_SCHEMA }),
+    prompt: buildExtractionPrompt(userInput, assistantText)
+  });
+  return output;
+};
+const buildEpisodePrompt = (userInput, assistantText) => [
+  "Summarize the following exchange as ONE concise past-tense sentence for a long-term memory log.",
+  "Capture what the user wanted and what was done or decided — a durable fact worth recalling in a later conversation.",
+  "No preamble and no quotes: return only the sentence.",
+  "",
+  `User: ${userInput}`,
+  "",
+  `Assistant: ${assistantText}`
+].join("\n");
+const createEpisodeExtract = () => async ({ assistantText, env, model, userInput }) => {
+  const { text } = await generateText({
+    model: resolveAgentModel(model, env),
+    prompt: buildEpisodePrompt(userInput, assistantText)
+  });
+  return { summary: text.trim() };
+};
+const COMPACTION_SYSTEM = "You are compacting an ongoing conversation. Summarize the messages so far into a concise brief that preserves decisions made, facts established, open questions, and current task state — everything the assistant needs to continue coherently. Write it as notes for the assistant, not a reply to the user. No preamble.";
+const createCompact = () => async ({ env, messages, model }) => {
+  const { text } = await generateText({
+    messages,
+    model: resolveAgentModel(model, env),
+    system: COMPACTION_SYSTEM
+  });
+  return text.trim();
+};
+
+export { createAgentGenerate, createCompact, createEpisodeExtract, createGraphExtract, createStreamGenerate, resolveAgentModel };

package/dist/packem_shared/createDispatchRunner-DSbp_dph-ZHTtxy3f.mjs

@@ -0,0 +1,69 @@
+import { LunoraError } from '@lunora/errors';
+
+const SCHEDULER_DISPATCH_PATH = "/_lunora/scheduler/dispatch";
+const trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+const toDispatchError = (label, status, rawBody) => {
+  try {
+    const parsed = JSON.parse(rawBody);
+    const errorBody = parsed?.error;
+    if (typeof errorBody === "object" && errorBody !== null && typeof errorBody.code === "string") {
+      const { code, data, message } = errorBody;
+      return new LunoraError(code, typeof message === "string" ? message : void 0, { data, status });
+    }
+  } catch {
+  }
+  return new LunoraError("INTERNAL", `${label}: function dispatch failed (${String(status)}): ${rawBody}`, { status });
+};
+const createDispatchRunner = (options) => {
+  const { label } = options;
+  const globalFetch = globalThis.fetch;
+  const fetchImpl = options.fetchImpl ?? (typeof globalFetch === "function" ? globalFetch.bind(globalThis) : void 0);
+  return async (function_, args, runOptions = {}) => {
+    if (typeof fetchImpl !== "function") {
+      throw new TypeError(`${label}: no fetch implementation available — pass fetchImpl or run on a platform with global fetch`);
+    }
+    const origin = options.env.LUNORA_ORIGIN_URL;
+    if (typeof origin !== "string" || origin.length === 0) {
+      throw new LunoraError("INTERNAL", `${label}: \`LUNORA_ORIGIN_URL\` must be set on the Worker env so a handler can call back into Lunora functions`);
+    }
+    const token = options.env.LUNORA_ADMIN_TOKEN;
+    if (typeof token !== "string" || token.length === 0) {
+      throw new LunoraError("INTERNAL", `${label}: \`LUNORA_ADMIN_TOKEN\` must be set on the Worker env to authenticate function dispatch`);
+    }
+    const url = `${trimTrailingSlashes(origin)}${SCHEDULER_DISPATCH_PATH}`;
+    const headers = { authorization: `Bearer ${token}`, "content-type": "application/json" };
+    if (options.identity?.userId !== void 0) {
+      headers["x-lunora-userid"] = options.identity.userId;
+    }
+    if (options.identity?.claims !== void 0) {
+      headers["x-lunora-identity"] = JSON.stringify(options.identity.claims);
+    }
+    const response = await fetchImpl(url, {
+      body: JSON.stringify({ args: args ?? {}, functionPath: function_.__lunoraRef, shardKey: runOptions.shardKey }),
+      headers,
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw toDispatchError(label, response.status, await response.text());
+    }
+    const text = await response.text();
+    if (text.length === 0) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new LunoraError("INTERNAL", `${label}: function dispatch returned a non-JSON body (${String(response.status)}): ${text}`, {
+        status: response.status
+      });
+    }
+  };
+};
+
+export { createDispatchRunner as c };

package/dist/packem_shared/defineAgent-D6maSbVc.mjs

@@ -0,0 +1,148 @@
+import { LunoraError } from '@lunora/errors';
+import { collectAgenticMemoryTools } from './collectAgenticMemoryTools-QrzpV-WX.mjs';
+import { agentAsTool } from './agentAsTool-Dt8NlU6k.mjs';
+import { i as isInjectedMemorySource } from './memory-D4FPcBsX.mjs';
+import { SKILL_NAME_PATTERN, RESERVED_SKILL_NAME } from './defineSkill-Ctf_S-rz.mjs';
+
+const TOOL_NAME_PATTERN = /^[a-zA-Z][\w-]*$/u;
+const mergeSkillTools = (config, skills) => {
+  const tools = { ...config.tools };
+  for (const skill of skills) {
+    for (const [toolName, tool] of Object.entries(skill.tools ?? {})) {
+      if (Object.hasOwn(tools, toolName)) {
+        throw new LunoraError(
+          "INTERNAL",
+          `@lunora/agent: skill "${skill.name}" tool "${toolName}" collides with an existing tool — rename one (the agent's tool namespace is flat)`
+        );
+      }
+      tools[toolName] = tool;
+    }
+  }
+  return tools;
+};
+const composeInstructions = (config, skills) => {
+  const fragments = [];
+  for (const fragment of [config.instructions, ...skills.map((skill) => skill.instructions)]) {
+    if (fragment) {
+      fragments.push(fragment);
+    }
+  }
+  if (fragments.length <= 1) {
+    return fragments[0];
+  }
+  return (context) => fragments.map((fragment) => typeof fragment === "function" ? fragment(context) : fragment).filter((text) => text.length > 0).join("\n\n");
+};
+const collectMemorySources = (config, skills) => {
+  const sources = [];
+  if (config.memory && isInjectedMemorySource(config.memory)) {
+    sources.push({ key: "default", ...config.memory });
+  }
+  for (const skill of skills) {
+    if (skill.knowledge && isInjectedMemorySource(skill.knowledge)) {
+      sources.push({ key: skill.name, ...skill.knowledge });
+    }
+  }
+  return sources;
+};
+const assertValidSkillNames = (skills) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const skill of skills) {
+    if (typeof skill.name !== "string" || !SKILL_NAME_PATTERN.test(skill.name)) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: skill \`name\` must be a valid identifier (letters, digits, _ or -, starting with a letter), got ${JSON.stringify(skill.name)}`
+      );
+    }
+    if (skill.name === RESERVED_SKILL_NAME) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: skill name "${RESERVED_SKILL_NAME}" is reserved (it keys the agent's own \`memory\` source / the \`memory:retrieve\` step) — choose another name`
+      );
+    }
+    if (seen.has(skill.name)) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: skill name "${skill.name}" is used by more than one skill — rename one (a skill name keys its knowledge memory source, which must be unique)`
+      );
+    }
+    seen.add(skill.name);
+  }
+};
+const assertActiveToolsExposeMemory = (activeTools, agenticMemoryTools) => {
+  if (activeTools === void 0) {
+    return;
+  }
+  const unreachable = Object.keys(agenticMemoryTools).filter((name) => !activeTools.includes(name));
+  if (unreachable.length > 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/agent: \`activeTools\` omits the agentic-memory tool(s) ${unreachable.map((name) => `"${name}"`).join(", ")} — the model could never call them; add them to \`activeTools\` (or drop \`activeTools\` to expose every tool)`
+    );
+  }
+};
+const assertMemorySourcesConfigured = (config, skills) => {
+  const requireSource = (memory, label) => {
+    if (memory && memory.kind !== "graph" && memory.kind !== "episodic" && memory.source === void 0) {
+      throw new LunoraError("INTERNAL", `@lunora/agent: ${label} requires a \`source\` action unless \`kind: "graph"\` or \`kind: "episodic"\``);
+    }
+  };
+  requireSource(config.memory, "`memory`");
+  for (const skill of skills) {
+    requireSource(skill.knowledge, `skill "${skill.name}" \`knowledge\``);
+  }
+};
+const defineAgent = (config) => {
+  const model = config.model;
+  if (model === void 0 || model === null || typeof model === "string" && model.length === 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      "@lunora/agent: defineAgent requires a `model` (a Workers AI id, an AI SDK LanguageModel, or an (env) => model thunk)"
+    );
+  }
+  if (config.maxTurns !== void 0 && (!Number.isInteger(config.maxTurns) || config.maxTurns < 1)) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: `maxTurns` must be a positive integer");
+  }
+  const skills = config.skills ?? [];
+  assertValidSkillNames(skills);
+  assertMemorySourcesConfigured(config, skills);
+  const tools = mergeSkillTools(config, skills);
+  const agenticMemoryTools = collectAgenticMemoryTools(config, skills);
+  for (const [toolName, tool] of Object.entries(agenticMemoryTools)) {
+    if (Object.hasOwn(tools, toolName)) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: agentic-memory tool "${toolName}" collides with an existing tool — rename one (the agent's tool namespace is flat)`
+      );
+    }
+    tools[toolName] = tool;
+  }
+  const hasAgenticTools = Object.keys(agenticMemoryTools).length > 0;
+  assertActiveToolsExposeMemory(config.activeTools, agenticMemoryTools);
+  for (const name of Object.keys(tools)) {
+    if (!TOOL_NAME_PATTERN.test(name)) {
+      throw new LunoraError("INTERNAL", `@lunora/agent: tool name "${name}" is not a valid identifier (letters, digits, _ or -, starting with a letter)`);
+    }
+  }
+  const memorySources = collectMemorySources(config, skills);
+  const composedInstructions = composeInstructions(config, skills);
+  return {
+    ...config,
+    asTool: agentAsTool,
+    isLunoraAgent: true,
+    ...skills.some((skill) => Boolean(skill.instructions)) ? { instructions: composedInstructions } : {},
+    ...memorySources.length > 0 ? { memorySources } : {},
+    ...skills.length > 0 || hasAgenticTools ? { tools } : {}
+  };
+};
+const isAgentDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraAgent === true;
+const defineAgentTool = (config) => {
+  if (typeof config.execute !== "function") {
+    throw new LunoraError("INTERNAL", "@lunora/agent: defineAgentTool requires an `execute` function");
+  }
+  if (typeof config.description !== "string" || config.description.length === 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: defineAgentTool requires a non-empty `description` (the model decides from it)");
+  }
+  return { ...config, isLunoraAgentTool: true };
+};
+
+export { defineAgent, defineAgentTool, isAgentDefinition };

package/dist/packem_shared/defineSkill-Ctf_S-rz.mjs

@@ -0,0 +1,22 @@
+import { LunoraError } from '@lunora/errors';
+
+const SKILL_NAME_PATTERN = /^[a-zA-Z][\w-]*$/u;
+const RESERVED_SKILL_NAME = "default";
+const defineSkill = (config) => {
+  if (typeof config.name !== "string" || !SKILL_NAME_PATTERN.test(config.name)) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/agent: defineSkill requires a \`name\` that is a valid identifier (letters, digits, _ or -, starting with a letter), got ${JSON.stringify(config.name)}`
+    );
+  }
+  if (config.name === RESERVED_SKILL_NAME) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/agent: skill name "${RESERVED_SKILL_NAME}" is reserved (it keys the agent's own \`memory\` source / the historic \`memory:retrieve\` step) — choose another name`
+    );
+  }
+  return { ...config, isLunoraSkill: true };
+};
+const isSkillDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraSkill === true;
+
+export { RESERVED_SKILL_NAME, SKILL_NAME_PATTERN, defineSkill, isSkillDefinition };

package/dist/packem_shared/functionTool-D6lCa2jB.mjs

@@ -0,0 +1,20 @@
+import { LunoraError } from '@lunora/errors';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const functionTool = (reference, options) => {
+  if (typeof options.description !== "string" || options.description.length === 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: functionTool requires a non-empty `description` (the model decides from it)");
+  }
+  if (options.inputSchema === void 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: functionTool requires an `inputSchema` (a zod schema or `jsonSchema(...)`)");
+  }
+  const target = toFunctionReference(reference);
+  return {
+    description: options.description,
+    execute: (input, context) => context.run(target, input),
+    inputSchema: options.inputSchema,
+    isLunoraAgentTool: true
+  };
+};
+
+export { functionTool };

package/dist/packem_shared/graph-component-aoUwO-f0.mjs

@@ -0,0 +1,216 @@
+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 }).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 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("byOwnerName", (q) => q.eq("owner", args.owner)).collect();
+    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

@@ -0,0 +1,12 @@
+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 };