@lunora/agent 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/normalizeEntityName-BouctxLC.mjs

@@ -0,0 +1,3 @@
+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-DU5ZmoEV.mjs

@@ -0,0 +1,177 @@
+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 buildResourceAttributes = (serviceName, extra) => {
+  const merged = { "service.name": serviceName };
+  for (const [key, value] of Object.entries({})) {
+    merged[key] = value;
+  }
+  return Object.entries(merged).map(([key, value]) => encodeAttribute(key, value));
+};
+const wrapResourceSpans = (span, scopeName, serviceName, resourceAttributes) => {
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: buildResourceAttributes(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 };

package/dist/packem_shared/runAgentLoop-M8PKbtWT.mjs

@@ -0,0 +1,493 @@
+import { resolveAgentModel } from './createAgentGenerate-DO7Z96zX.mjs';
+import { f as firstGraphSource, m as memoryStepName, a as firstEpisodicSource, r as resolveInjectedSources } from './memory-D4FPcBsX.mjs';
+import { buildModelMessages } from './buildModelMessages-BWFigaoo.mjs';
+import { agentBindingName } from '../naming.mjs';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const DEFAULT_MAX_TURNS = 8;
+const stringifyOutput = (output) => output === void 0 ? "null" : JSON.stringify(output);
+const normalizeStopWhen = (stopWhen) => {
+  if (stopWhen === void 0) {
+    return [];
+  }
+  if (Array.isArray(stopWhen)) {
+    return stopWhen;
+  }
+  return [stopWhen];
+};
+const isStopConditionMet = async (conditions, steps) => {
+  const results = await Promise.all(conditions.map(async (condition) => condition({ steps })));
+  return results.some(Boolean);
+};
+const sumTokens = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+const addUsage = (base, next) => {
+  if (next === void 0) {
+    return base;
+  }
+  if (base === void 0) {
+    return { ...next };
+  }
+  const result = {};
+  const inputTokens = sumTokens(base.inputTokens, next.inputTokens);
+  const outputTokens = sumTokens(base.outputTokens, next.outputTokens);
+  const totalTokens = sumTokens(base.totalTokens, next.totalTokens);
+  if (inputTokens !== void 0) {
+    result.inputTokens = inputTokens;
+  }
+  if (outputTokens !== void 0) {
+    result.outputTokens = outputTokens;
+  }
+  if (totalTokens !== void 0) {
+    result.totalTokens = totalTokens;
+  }
+  return result;
+};
+const resolveNeedsApproval = async (tool, input, context) => {
+  const { needsApproval } = tool;
+  if (needsApproval === void 0 || needsApproval === false) {
+    return false;
+  }
+  if (needsApproval === true) {
+    return true;
+  }
+  return needsApproval(input, context);
+};
+const awaitApproval = async (turnContext, call) => {
+  const { instanceId, patchThread, persist, step } = turnContext;
+  await persist({
+    content: `Awaiting approval to run tool "${call.name}".`,
+    messageKey: `${instanceId}:approval:${call.id}`,
+    role: "tool",
+    status: "awaiting_approval",
+    toolCallId: call.id,
+    toolName: call.name
+  });
+  await patchThread({ status: "awaiting_input" });
+  const event = await step.waitForEvent(`approval:${call.id}`, { type: `agent-approval:${call.id}` });
+  await patchThread({ status: "running" });
+  return { decision: event.payload.decision, ...event.payload.note === void 0 ? {} : { note: event.payload.note } };
+};
+const runToolCall = async (turnContext, call) => {
+  const { env, getState, instanceId, onTokenDelta, persist, run, setState, step, threadKey, tools } = turnContext;
+  const stepName = `tool:${call.name}:${call.id}`;
+  const tool = tools[call.name];
+  const messageKey = `${instanceId}:tool:${call.id}`;
+  if (!tool) {
+    await persist({ content: `Error: unknown tool "${call.name}"`, messageKey, role: "tool", stepName, toolCallId: call.id, toolName: call.name });
+    return;
+  }
+  const reportProgress = (data) => {
+    onTokenDelta?.({ data, kind: "progress", threadKey, toolCallId: call.id });
+  };
+  const toolContext = { env, getState, idempotencyKey: stepName, reportProgress, run, setState, threadKey, toolCallId: call.id };
+  let status;
+  if (await resolveNeedsApproval(tool, call.input, toolContext)) {
+    const { decision, note } = await awaitApproval(turnContext, call);
+    if (decision === "reject") {
+      const reason = note === void 0 ? "" : ` Reason: ${note}`;
+      await persist({
+        content: `Tool "${call.name}" was rejected by the user and not run.${reason}`,
+        messageKey,
+        role: "tool",
+        status: "rejected",
+        stepName,
+        toolCallId: call.id,
+        toolName: call.name
+      });
+      return;
+    }
+    status = "approved";
+  }
+  const output = await step.do(stepName, () => Promise.resolve(tool.execute(call.input, toolContext)));
+  await persist({
+    content: typeof output === "string" ? output : stringifyOutput(output),
+    messageKey,
+    role: "tool",
+    stepName,
+    ...status === void 0 ? {} : { status },
+    toolCallId: call.id,
+    toolName: call.name
+  });
+};
+const applyPrepareStepResult = (base, overrides, env) => {
+  if (!overrides) {
+    return base;
+  }
+  let { messages } = base;
+  if (overrides.messages !== void 0) {
+    messages = overrides.messages;
+  }
+  if (overrides.system !== void 0) {
+    messages = [{ content: overrides.system, role: "system" }, ...messages];
+  }
+  return {
+    activeTools: overrides.activeTools ?? base.activeTools,
+    messages,
+    model: overrides.model === void 0 ? base.model : resolveAgentModel(overrides.model, env),
+    toolChoice: overrides.toolChoice ?? base.toolChoice
+  };
+};
+const splitForCompaction = (history, compaction) => {
+  if (compaction === void 0 || history.length <= compaction.maxMessages) {
+    return void 0;
+  }
+  const keepRecent = Math.max(1, compaction.keepRecent ?? Math.ceil(compaction.maxMessages / 2));
+  if (history.length <= keepRecent) {
+    return void 0;
+  }
+  let cut = history.length - keepRecent;
+  while (cut > 0 && history[cut]?.role === "tool") {
+    cut -= 1;
+  }
+  if (cut <= 0) {
+    return void 0;
+  }
+  return { older: history.slice(0, cut), recent: history.slice(cut) };
+};
+const compactHistory = async (turnContext, history) => {
+  const { agent, compact, env } = turnContext;
+  const split = splitForCompaction(history, agent.compaction);
+  if (split === void 0 || compact === void 0) {
+    return { history, summary: void 0 };
+  }
+  try {
+    const summary = await compact({ env, messages: buildModelMessages({ history: split.older }), model: agent.compaction?.model ?? agent.model });
+    return summary.length > 0 ? { history: split.recent, summary } : { history, summary: void 0 };
+  } catch {
+    return { history, summary: void 0 };
+  }
+};
+const generateTurn = async (turnContext, turn, steps) => {
+  const { agent, env, generate, instructions, listMessages, memoryContext, onTokenDelta, run, step, streamGenerate, threadKey } = turnContext;
+  return step.do(`llm:turn:${String(turn)}`, async () => {
+    const rawHistory = await run(listMessages, { key: threadKey });
+    const { history, summary } = await compactHistory(turnContext, rawHistory);
+    let prepared = {
+      activeTools: agent.activeTools,
+      messages: buildModelMessages({ history, instructions, memoryContext, summary }),
+      model: void 0,
+      toolChoice: agent.toolChoice
+    };
+    if (agent.prepareStep) {
+      prepared = applyPrepareStepResult(prepared, await agent.prepareStep({ messages: prepared.messages, stepNumber: turn, steps }), env);
+    }
+    const request = {
+      messages: prepared.messages,
+      ...prepared.activeTools === void 0 ? {} : { activeTools: prepared.activeTools },
+      ...prepared.model === void 0 ? {} : { model: prepared.model },
+      ...prepared.toolChoice === void 0 ? {} : { toolChoice: prepared.toolChoice }
+    };
+    if (streamGenerate && onTokenDelta) {
+      return streamGenerate(request, (text) => {
+        onTokenDelta({ text, threadKey, turn });
+      });
+    }
+    return generate(request);
+  });
+};
+const notifyStepFinish = async (turnContext, info) => {
+  const { agent, step } = turnContext;
+  if (!agent.onStepFinish) {
+    return;
+  }
+  await step.do(`agent:step-finish:${String(info.turn)}`, async () => {
+    await agent.onStepFinish?.(info);
+    return true;
+  });
+};
+const toStepInfo = (decision) => {
+  return {
+    text: decision.text,
+    toolCalls: decision.toolCalls.map((call) => {
+      return { input: call.input, toolCallId: call.id, toolName: call.name };
+    }),
+    ...decision.usage === void 0 ? {} : { usage: decision.usage }
+  };
+};
+const readRetrievedContext = (retrieved) => {
+  const context = retrieved?.context;
+  return typeof context === "string" && context.length > 0 ? context : void 0;
+};
+const graphTraverseBounds = (graph) => {
+  const bounds = {};
+  if (graph?.depth !== void 0) {
+    bounds.depth = graph.depth;
+  }
+  if (graph?.fanOut !== void 0) {
+    bounds.fanOut = graph.fanOut;
+  }
+  if (graph?.maxNodes !== void 0) {
+    bounds.maxNodes = graph.maxNodes;
+  }
+  if (graph?.maxSeeds !== void 0) {
+    bounds.maxSeeds = graph.maxSeeds;
+  }
+  return bounds;
+};
+const dispatchSemanticMemory = async (source, input, step, run) => {
+  if (source.source === void 0) {
+    return void 0;
+  }
+  const memorySource = toFunctionReference(source.source);
+  const { topK } = source;
+  const stepName = memoryStepName("memory:retrieve", source.key);
+  const retrieved = await step.do(stepName, async () => run(memorySource, { query: input, ...topK === void 0 ? {} : { topK } }));
+  return readRetrievedContext(retrieved);
+};
+const dispatchGraphMemory = async (source, input, owner, graphTraverse, step, run) => {
+  if (owner === void 0) {
+    return void 0;
+  }
+  const stepName = memoryStepName("memory:traverse", source.key);
+  const retrieved = await step.do(stepName, async () => run(graphTraverse, { owner, query: input, ...graphTraverseBounds(source.graph) }));
+  return readRetrievedContext(retrieved);
+};
+const dispatchEpisodicMemory = async (source, owner, episodeRecall, step, run) => {
+  if (owner === void 0) {
+    return void 0;
+  }
+  const stepName = memoryStepName("memory:recall", source.key);
+  const recallArgs = { owner, ...source.episodic?.recall === void 0 ? {} : { limit: source.episodic.recall } };
+  const retrieved = await step.do(stepName, async () => run(episodeRecall, recallArgs));
+  return readRetrievedContext(retrieved);
+};
+const dispatchInjectedSource = async (source, deps) => {
+  if (source.kind === "episodic") {
+    return dispatchEpisodicMemory(source, deps.owner, deps.episodeRecall, deps.step, deps.run);
+  }
+  if (source.kind === "graph") {
+    return dispatchGraphMemory(source, deps.input, deps.owner, deps.graphTraverse, deps.step, deps.run);
+  }
+  return dispatchSemanticMemory(source, deps.input, deps.step, deps.run);
+};
+const dedupeEpisodicSources = (sources) => {
+  let seenEpisodic = false;
+  return sources.filter((source) => {
+    if (source.kind !== "episodic") {
+      return true;
+    }
+    if (seenEpisodic) {
+      return false;
+    }
+    seenEpisodic = true;
+    return true;
+  });
+};
+const retrieveMemoryContext = async (agent, input, owner, paths, step, run) => {
+  const sources = dedupeEpisodicSources(resolveInjectedSources(agent));
+  if (sources.length === 0) {
+    return void 0;
+  }
+  const graphTraverse = toFunctionReference(paths.graphTraverse);
+  const episodeRecall = toFunctionReference(paths.episodeRecall);
+  const contexts = [];
+  for (const source of sources) {
+    const context = await dispatchInjectedSource(source, { episodeRecall, graphTraverse, input, owner, run, step });
+    if (context !== void 0) {
+      contexts.push(context);
+    }
+  }
+  return contexts.length > 0 ? contexts.join("\n\n") : void 0;
+};
+const extractGraphMemoryAtRunEnd = async (options) => {
+  const { agent, env, extractGraph, finalText, input, instanceId, owner, paths, run, step } = options;
+  if (extractGraph === void 0 || owner === void 0 || finalText === void 0 || finalText.length === 0) {
+    return;
+  }
+  const source = firstGraphSource(agent);
+  if (source === void 0) {
+    return;
+  }
+  try {
+    const graphInput = { assistantText: finalText, env, model: source.graph?.extractionModel ?? agent.model, userInput: input };
+    const extracted = await step.do(memoryStepName("memory:extract", source.key), async () => extractGraph(graphInput));
+    await run(toFunctionReference(paths.graphUpsert), { ...extracted, messageKey: `${instanceId}:${memoryStepName("extract", source.key)}`, owner });
+  } catch {
+  }
+};
+const extractEpisodeAtRunEnd = async (options) => {
+  const { agent, env, extractEpisode, finalText, input, instanceId, owner, paths, run, step, threadKey } = options;
+  if (extractEpisode === void 0 || owner === void 0 || finalText === void 0 || finalText.length === 0) {
+    return;
+  }
+  const source = firstEpisodicSource(agent);
+  if (source === void 0) {
+    return;
+  }
+  try {
+    const episodeInput = { assistantText: finalText, env, model: source.episodic?.extractionModel ?? agent.model, userInput: input };
+    const { summary } = await step.do(memoryStepName("memory:episode", source.key), async () => extractEpisode(episodeInput));
+    await run(toFunctionReference(paths.episodeUpsert), {
+      messageKey: `${instanceId}:${memoryStepName("episode", source.key)}`,
+      owner,
+      summary,
+      threadKey
+    });
+  } catch {
+  }
+};
+const terminatePriorInstance = async (env, exportName, priorInstanceId) => {
+  const binding = env[agentBindingName(exportName)];
+  if (!binding || typeof binding.get !== "function") {
+    return;
+  }
+  try {
+    const instance = await binding.get(priorInstanceId);
+    await instance.terminate();
+  } catch {
+  }
+};
+const handleTurn = async (turnContext, turn, decision, steps, stopConditions) => {
+  const { instanceId, persist } = turnContext;
+  const stepUsage = decision.usage === void 0 ? {} : { usage: decision.usage };
+  if (decision.toolCalls.length === 0) {
+    const content = decision.output !== void 0 && decision.text.length === 0 ? stringifyOutput(decision.output) : decision.text;
+    await persist({ content, messageKey: `${instanceId}:assistant:${String(turn)}`, role: "assistant" });
+    await notifyStepFinish(turnContext, { text: decision.text, toolCalls: [], turn, ...stepUsage });
+    return {
+      final: {
+        stopped: "final",
+        text: decision.text,
+        turns: turn + 1,
+        ...decision.output === void 0 ? {} : { output: decision.output }
+      }
+    };
+  }
+  await persist({ content: decision.text, messageKey: `${instanceId}:assistant:${String(turn)}`, role: "assistant", toolCalls: decision.toolCalls });
+  for (const call of decision.toolCalls) {
+    await runToolCall(turnContext, call);
+  }
+  await notifyStepFinish(turnContext, { text: decision.text, toolCalls: decision.toolCalls, turn, ...stepUsage });
+  steps.push(toStepInfo(decision));
+  if (stopConditions.length > 0 && await isStopConditionMet(stopConditions, steps)) {
+    return "stopCondition";
+  }
+  return void 0;
+};
+const runTurns = async (turnContext, maxTurns, stopConditions, usageBox) => {
+  const steps = [];
+  let final;
+  let stoppedByCondition = false;
+  let turnsRun = 0;
+  for (let turn = 0; turn < maxTurns; turn += 1) {
+    const decision = await generateTurn(turnContext, turn, steps);
+    usageBox.value = addUsage(usageBox.value, decision.usage);
+    turnsRun = turn + 1;
+    const outcome = await handleTurn(turnContext, turn, decision, steps, stopConditions);
+    if (outcome === "stopCondition") {
+      stoppedByCondition = true;
+      break;
+    }
+    if (outcome !== void 0) {
+      final = outcome.final;
+      break;
+    }
+  }
+  return { final, stoppedByCondition, turnsRun };
+};
+const runAgentLoop = async (options) => {
+  const { agent, compact, env, exportName, extractEpisode, extractGraph, generate, instanceId, onTokenDelta, params, paths, run, step, streamGenerate } = options;
+  const maxTurns = agent.maxTurns ?? DEFAULT_MAX_TURNS;
+  const stopConditions = normalizeStopWhen(agent.stopWhen);
+  const appendMessage = toFunctionReference(paths.appendMessage);
+  const ensureThread = toFunctionReference(paths.ensureThread);
+  const listMessages = toFunctionReference(paths.listMessages);
+  const patchThread = toFunctionReference(paths.patchThread);
+  const setStateRef = toFunctionReference(paths.setState);
+  const stateRef = toFunctionReference(paths.state);
+  const persist = async (message) => {
+    await run(appendMessage, { threadKey: params.threadKey, ...message });
+  };
+  const patchThreadByKey = async (patch) => {
+    await run(patchThread, { key: params.threadKey, ...patch });
+  };
+  const getState = async () => await run(stateRef, { key: params.threadKey });
+  const setState = async (state) => {
+    await run(setStateRef, { key: params.threadKey, state });
+  };
+  const bootstrap = await run(ensureThread, {
+    agent: exportName,
+    instanceId,
+    key: params.threadKey,
+    ...agent.initialState === void 0 ? {} : { initialState: agent.initialState },
+    ...agent.onConcurrentRun === void 0 ? {} : { onConcurrentRun: agent.onConcurrentRun },
+    ...params.owner === void 0 ? {} : { owner: params.owner },
+    ...params.title === void 0 ? {} : { title: params.title }
+  });
+  if (bootstrap?.replaced && bootstrap.priorInstanceId !== void 0) {
+    await terminatePriorInstance(env, exportName, bootstrap.priorInstanceId);
+  }
+  await persist({ content: params.input, messageKey: `${instanceId}:user`, role: "user" });
+  const memoryContext = await retrieveMemoryContext(agent, params.input, params.owner, paths, step, run);
+  const instructions = typeof agent.instructions === "function" ? agent.instructions({ env, input: params.input, threadKey: params.threadKey }) : agent.instructions;
+  const turnContext = {
+    agent,
+    compact,
+    env,
+    generate,
+    getState,
+    instanceId,
+    instructions,
+    listMessages,
+    memoryContext,
+    onTokenDelta,
+    patchThread: patchThreadByKey,
+    persist,
+    run,
+    setState,
+    step,
+    streamGenerate,
+    threadKey: params.threadKey,
+    tools: agent.tools ?? {}
+  };
+  const usageBox = { value: void 0 };
+  try {
+    const { final, stoppedByCondition, turnsRun } = await runTurns(turnContext, maxTurns, stopConditions, usageBox);
+    const usagePatch = usageBox.value === void 0 ? {} : { usage: usageBox.value };
+    await extractGraphMemoryAtRunEnd({
+      agent,
+      env,
+      extractGraph,
+      finalText: final?.text,
+      input: params.input,
+      instanceId,
+      owner: params.owner,
+      paths,
+      run,
+      step
+    });
+    await extractEpisodeAtRunEnd({
+      agent,
+      env,
+      extractEpisode,
+      finalText: final?.text,
+      input: params.input,
+      instanceId,
+      owner: params.owner,
+      paths,
+      run,
+      step,
+      threadKey: params.threadKey
+    });
+    if (final) {
+      await run(patchThread, { key: params.threadKey, status: "idle", ...usagePatch });
+      return { ...final, ...usagePatch };
+    }
+    if (stoppedByCondition) {
+      await run(patchThread, { key: params.threadKey, status: "idle", ...usagePatch });
+      return { stopped: "stopCondition", turns: turnsRun, ...usagePatch };
+    }
+    await run(patchThread, { error: `agent stopped: maxTurns (${String(maxTurns)}) reached`, key: params.threadKey, status: "error", ...usagePatch });
+    return { stopped: "maxTurns", turns: maxTurns, ...usagePatch };
+  } catch (error) {
+    await run(patchThread, {
+      error: error instanceof Error ? error.message : String(error),
+      key: params.threadKey,
+      status: "error",
+      ...usageBox.value === void 0 ? {} : { usage: usageBox.value }
+    });
+    throw error;
+  }
+};
+
+export { runAgentLoop, splitForCompaction };