@lunora/agent 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/buildModelMessages-BWFigaoo.mjs

@@ -0,0 +1,69 @@
+const assistantMessage = (row) => {
+  if (row.toolCalls === void 0 || row.toolCalls.length === 0) {
+    return { content: row.content, role: "assistant" };
+  }
+  return {
+    content: [
+      ...row.content.length > 0 ? [{ text: row.content, type: "text" }] : [],
+      ...row.toolCalls.map((call) => {
+        return { input: call.input, toolCallId: call.id, toolName: call.name, type: "tool-call" };
+      })
+    ],
+    role: "assistant"
+  };
+};
+const toolMessage = (row) => {
+  return {
+    content: [
+      {
+        output: { type: "text", value: row.content },
+        toolCallId: row.toolCallId ?? "",
+        toolName: row.toolName ?? "",
+        type: "tool-result"
+      }
+    ],
+    role: "tool"
+  };
+};
+const buildModelMessages = (options) => {
+  const messages = [];
+  if (options.instructions !== void 0 && options.instructions.length > 0) {
+    messages.push({ content: options.instructions, role: "system" });
+  }
+  if (options.memoryContext !== void 0 && options.memoryContext.length > 0) {
+    messages.push({ content: `Relevant context retrieved for this conversation:
+
+${options.memoryContext}`, role: "system" });
+  }
+  if (options.summary !== void 0 && options.summary.length > 0) {
+    messages.push({ content: `Summary of the earlier conversation:
+
+${options.summary}`, role: "system" });
+  }
+  for (const row of options.history) {
+    if (row.status === "awaiting_approval") {
+      continue;
+    }
+    switch (row.role) {
+      case "assistant": {
+        messages.push(assistantMessage(row));
+        break;
+      }
+      case "system": {
+        messages.push({ content: row.content, role: "system" });
+        break;
+      }
+      case "tool": {
+        messages.push(toolMessage(row));
+        break;
+      }
+      case "user": {
+        messages.push({ content: row.content, role: "user" });
+        break;
+      }
+    }
+  }
+  return messages;
+};
+
+export { buildModelMessages };

package/dist/packem_shared/codeTool-CjgJOC9t.mjs

@@ -0,0 +1,122 @@
+import { LunoraError } from '@lunora/errors';
+import { jsonSchema } from 'ai';
+
+const DEFAULT_MAX_STEPS = 16;
+const MAX_STEP_OUTPUT_CHARS = 4e3;
+const capOutput = (output) => {
+  if (output === void 0) {
+    return output;
+  }
+  const serialized = typeof output === "string" ? output : JSON.stringify(output);
+  if (serialized.length <= MAX_STEP_OUTPUT_CHARS) {
+    return output;
+  }
+  return `${serialized.slice(0, MAX_STEP_OUTPUT_CHARS)}… [truncated]`;
+};
+const getPath = (value, path) => {
+  let current = value;
+  for (const key of path.split(".")) {
+    if (current === null || typeof current !== "object" || !Object.hasOwn(current, key)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+};
+const resolveReferences = (value, results) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveReferences(item, results));
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const object = value;
+  if (typeof object["$from"] === "string") {
+    const from = object["$from"];
+    if (!(from in results)) {
+      throw new LunoraError("BAD_REQUEST", `@lunora/agent: code step references unknown result "${from}" (define it in an earlier step)`);
+    }
+    return typeof object["$path"] === "string" ? getPath(results[from], object["$path"]) : results[from];
+  }
+  const resolved = {};
+  for (const [key, nested] of Object.entries(object)) {
+    resolved[key] = resolveReferences(nested, results);
+  }
+  return resolved;
+};
+const runToolScript = async (script, tools, context, maxSteps) => {
+  const steps = Array.isArray(script.steps) ? script.steps.slice(0, maxSteps) : [];
+  const byId = {};
+  const results = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (seenIds.has(step.id)) {
+      throw new LunoraError(
+        "BAD_REQUEST",
+        `@lunora/agent: duplicate code step id "${step.id}" — each step id must be unique (later steps reference an output by id via $from)`
+      );
+    }
+    seenIds.add(step.id);
+  }
+  for (const step of steps) {
+    const tool = tools[step.tool];
+    if (!tool) {
+      throw new LunoraError("BAD_REQUEST", `@lunora/agent: code step calls unknown tool "${step.tool}" (available: ${Object.keys(tools).join(", ")})`);
+    }
+    const input = resolveReferences(step.input ?? {}, byId);
+    const stepContext = {
+      ...context,
+      idempotencyKey: `${context.idempotencyKey}:${step.id}`,
+      toolCallId: `${context.toolCallId}:${step.id}`
+    };
+    const output = await tool.execute(input, stepContext);
+    byId[step.id] = output;
+    results.push({ id: step.id, output: capOutput(output) });
+  }
+  return { final: results.at(-1)?.output, results };
+};
+const buildCodeDescription = (tools) => `Compose MULTIPLE tool calls in one turn as a script, instead of one call per turn. Provide \`steps\`: an ordered array of \`{ id, tool, input }\`. A later step's \`input\` may reference an earlier step's output with \`{ "$from": "<stepId>", "$path": "optional.dot.path" }\`. Available tools: ${Object.entries(tools).map(([name, tool]) => `"${name}" — ${tool.description}`).join("; ")}.`;
+const CODE_TOOL_SCHEMA = jsonSchema({
+  properties: {
+    steps: {
+      description: "Ordered tool calls; a later input may reference an earlier output via { $from, $path }.",
+      items: {
+        additionalProperties: false,
+        properties: {
+          id: { description: "A name later steps reference this output by.", type: "string" },
+          input: { additionalProperties: true, description: "The tool input (may embed $from refs).", type: "object" },
+          tool: { description: "The tool to call.", type: "string" }
+        },
+        required: ["id", "tool"],
+        type: "object"
+      },
+      type: "array"
+    }
+  },
+  required: ["steps"],
+  type: "object"
+});
+const codeTool = (tools, options = {}) => {
+  const provided = tools;
+  if (!provided || typeof provided !== "object" || Object.keys(provided).length === 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: codeTool requires a non-empty map of tools to compose");
+  }
+  for (const [name, tool] of Object.entries(provided)) {
+    if (tool.needsApproval !== void 0 && tool.needsApproval !== false) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: codeTool cannot compose "${name}" — it has a \`needsApproval\` gate a code-mode script can't pause for. Expose it as a normal top-level tool, or gate the whole script via codeTool's \`needsApproval\`.`
+      );
+    }
+  }
+  const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+  return {
+    description: options.description ?? buildCodeDescription(tools),
+    execute: (script, context) => runToolScript(script, tools, context, maxSteps),
+    inputSchema: CODE_TOOL_SCHEMA,
+    isLunoraAgentTool: true,
+    ...options.needsApproval === void 0 ? {} : { needsApproval: options.needsApproval }
+  };
+};
+
+export { codeTool, resolveReferences, runToolScript };

package/dist/packem_shared/collectAgenticMemoryTools-QrzpV-WX.mjs

@@ -0,0 +1,97 @@
+import { jsonSchema } from 'ai';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const DEFAULT_SNIPPET_CHARS = 240;
+const MAX_SEARCH_TOPK = 50;
+const snippet = (text, max) => text.length <= max ? text : `${text.slice(0, max)}…`;
+const clampSearchTopK = (value) => {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.min(MAX_SEARCH_TOPK, Math.max(1, Math.trunc(value)));
+};
+const toSearchResults = (retrieved, snippetChars) => {
+  const raw = retrieved ?? {};
+  const chunks = Array.isArray(raw.chunks) ? raw.chunks : [];
+  const sources = Array.isArray(raw.sources) ? raw.sources : [];
+  return {
+    results: chunks.map((chunk) => {
+      return {
+        id: typeof chunk.id === "string" ? chunk.id : "",
+        score: typeof chunk.score === "number" ? chunk.score : 0,
+        snippet: snippet(typeof chunk.text === "string" ? chunk.text : "", snippetChars),
+        sourceId: typeof chunk.sourceId === "string" ? chunk.sourceId : ""
+      };
+    }),
+    sources
+  };
+};
+const searchInputSchema = jsonSchema({
+  additionalProperties: false,
+  properties: {
+    query: { description: "Natural-language search query.", type: "string" },
+    topK: { description: "Maximum number of hits to return.", type: "number" }
+  },
+  required: ["query"],
+  type: "object"
+});
+const readInputSchema = jsonSchema({
+  additionalProperties: false,
+  properties: {
+    id: { description: "The `id` of a hit returned by the search tool.", type: "string" }
+  },
+  required: ["id"],
+  type: "object"
+});
+const buildSearchTool = (source, sourceReference, readToolName) => {
+  const target = toFunctionReference(sourceReference);
+  const snippetChars = Math.max(1, source.snippetChars ?? DEFAULT_SNIPPET_CHARS);
+  const configuredTopK = source.topK;
+  const pull = readToolName === void 0 ? "" : ` Use \`${readToolName}\` with a hit's \`id\` to fetch its full text.`;
+  return {
+    description: `Search long-term memory for passages relevant to a query. Returns ranked { id, sourceId, score, snippet } hits — call again with a refined query to dig deeper.${pull}`,
+    execute: async (input, context) => {
+      const topK = clampSearchTopK(input.topK) ?? configuredTopK;
+      const retrieved = await context.run(target, { query: input.query, ...topK === void 0 ? {} : { topK } });
+      return toSearchResults(retrieved, snippetChars);
+    },
+    inputSchema: searchInputSchema,
+    isLunoraAgentTool: true
+  };
+};
+const buildReadTool = (readReference) => {
+  const target = toFunctionReference(readReference);
+  return {
+    description: "Fetch the full text of a memory document by the `id` from a search hit.",
+    execute: (input, context) => context.run(target, { id: input.id }),
+    inputSchema: readInputSchema,
+    isLunoraAgentTool: true
+  };
+};
+const collectAgenticMemoryTools = (config, skills) => {
+  const sources = [];
+  if (config.memory) {
+    sources.push({ key: "default", ...config.memory });
+  }
+  for (const skill of skills) {
+    if (skill.knowledge) {
+      sources.push({ key: skill.name, ...skill.knowledge });
+    }
+  }
+  const tools = {};
+  for (const source of sources) {
+    if (source.kind === "graph" || source.kind === "episodic" || source.mode !== "agentic" || source.source === void 0) {
+      continue;
+    }
+    const searchName = source.key === "default" ? "searchMemory" : `search_${source.key}`;
+    const readName = source.key === "default" ? "readMemory" : `read_${source.key}`;
+    const hasRead = source.read !== void 0;
+    tools[searchName] = buildSearchTool(source, source.source, hasRead ? readName : void 0);
+    if (hasRead) {
+      tools[readName] = buildReadTool(source.read);
+    }
+  }
+  return tools;
+};
+
+export { collectAgenticMemoryTools, toSearchResults };

package/dist/packem_shared/combineTelemetry-DCyaaWAI.mjs

@@ -0,0 +1,43 @@
+const fanOut = (callbacks) => async (event) => {
+  await Promise.allSettled(callbacks.map(async (callback) => callback?.(event)));
+};
+const composeWrappers = (wrappers) => {
+  const defined = wrappers.filter((wrapper) => typeof wrapper === "function");
+  const combined = (options) => {
+    let composed = options.execute;
+    for (const wrapper of defined.toReversed()) {
+      const inner = composed;
+      composed = () => wrapper({ ...options, execute: inner });
+    }
+    return composed();
+  };
+  return combined;
+};
+const combineTelemetry = (...integrations) => {
+  return {
+    executeLanguageModelCall: composeWrappers(integrations.map((integration) => integration.executeLanguageModelCall)),
+    executeTool: composeWrappers(integrations.map((integration) => integration.executeTool)),
+    onAbort: fanOut(integrations.map((integration) => integration.onAbort)),
+    onEmbedEnd: fanOut(integrations.map((integration) => integration.onEmbedEnd)),
+    onEmbedStart: fanOut(integrations.map((integration) => integration.onEmbedStart)),
+    onEnd: fanOut(integrations.map((integration) => integration.onEnd)),
+    onError: fanOut(integrations.map((integration) => integration.onError)),
+    onLanguageModelCallEnd: fanOut(integrations.map((integration) => integration.onLanguageModelCallEnd)),
+    onLanguageModelCallStart: fanOut(integrations.map((integration) => integration.onLanguageModelCallStart)),
+    // eslint-disable-next-line sonarjs/deprecation -- deprecated in the ai@7 type but still actively dispatched (dist onObjectStepEnd fan-out); combine must not drop an integration's callback
+    onObjectStepEnd: fanOut(integrations.map((integration) => integration.onObjectStepEnd)),
+    // eslint-disable-next-line sonarjs/deprecation -- deprecated in the ai@7 type but still actively dispatched (dist onObjectStepStart fan-out); combine must not drop an integration's callback
+    onObjectStepStart: fanOut(integrations.map((integration) => integration.onObjectStepStart)),
+    onRerankEnd: fanOut(integrations.map((integration) => integration.onRerankEnd)),
+    onRerankStart: fanOut(integrations.map((integration) => integration.onRerankStart)),
+    onStart: fanOut(integrations.map((integration) => integration.onStart)),
+    onStepEnd: fanOut(integrations.map((integration) => integration.onStepEnd)),
+    // eslint-disable-next-line sonarjs/deprecation -- deprecated alias of onStepEnd but ai@7 still fans step-end events to it (dist onStepEnd → onStepFinish); combine must not drop an integration's callback
+    onStepFinish: fanOut(integrations.map((integration) => integration.onStepFinish)),
+    onStepStart: fanOut(integrations.map((integration) => integration.onStepStart)),
+    onToolExecutionEnd: fanOut(integrations.map((integration) => integration.onToolExecutionEnd)),
+    onToolExecutionStart: fanOut(integrations.map((integration) => integration.onToolExecutionStart))
+  };
+};
+
+export { combineTelemetry };

package/dist/packem_shared/common-DQXayow6.mjs

@@ -0,0 +1,89 @@
+const readField = (source, key) => {
+  if (source === null || typeof source !== "object") {
+    return void 0;
+  }
+  return source[key];
+};
+const summarizeUsage = (usage) => {
+  const summary = {};
+  for (const key of ["inputTokens", "outputTokens", "totalTokens"]) {
+    const value = readField(usage, key);
+    if (typeof value === "number") {
+      summary[key] = value;
+    }
+  }
+  return Object.keys(summary).length > 0 ? summary : void 0;
+};
+const summarizeGatewayTelemetry = (result) => {
+  const gateway = readField(readField(result, "providerMetadata"), "gateway");
+  const headers = readField(readField(result, "response"), "headers");
+  const readHeader = (name) => {
+    const getter = readField(headers, "get");
+    const value = typeof getter === "function" ? getter.call(headers, name) : readField(headers, name);
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  };
+  const summary = {};
+  const cost = readField(gateway, "cost");
+  if (typeof cost === "number" && Number.isFinite(cost)) {
+    summary.cost = cost;
+  }
+  const cachedField = readField(gateway, "cached");
+  const cacheStatusField = readField(gateway, "cacheStatus");
+  const cacheStatus = typeof cacheStatusField === "string" ? cacheStatusField : readHeader("cf-aig-cache-status");
+  if (typeof cachedField === "boolean") {
+    summary.cached = cachedField;
+  } else if (typeof cacheStatus === "string") {
+    summary.cached = cacheStatus.toUpperCase() === "HIT";
+  }
+  const metadataLogId = readField(gateway, "logId") ?? readField(gateway, "log_id");
+  const logId = typeof metadataLogId === "string" && metadataLogId.length > 0 ? metadataLogId : readHeader("cf-aig-log-id");
+  if (typeof logId === "string" && logId.length > 0) {
+    summary.logId = logId;
+  }
+  return Object.keys(summary).length > 0 ? summary : void 0;
+};
+const describeToolOutcome = (event) => {
+  const toolCall = readField(event, "toolCall");
+  const nameValue = readField(toolCall, "toolName");
+  const name = typeof nameValue === "string" ? nameValue : void 0;
+  const toolOutput = readField(event, "toolOutput");
+  const outputType = readField(toolOutput, "type");
+  const successField = readField(event, "success");
+  const success = typeof successField === "boolean" ? successField : outputType !== "tool-error";
+  const executionMs = readField(event, "toolExecutionMs");
+  return {
+    error: success ? void 0 : readField(toolOutput, "error") ?? readField(event, "error"),
+    name,
+    output: success ? readField(toolOutput, "output") : void 0,
+    success,
+    toolExecutionMs: typeof executionMs === "number" ? executionMs : void 0
+  };
+};
+const toolNameOf = (event) => {
+  const nameValue = readField(readField(event, "toolCall"), "toolName");
+  return typeof nameValue === "string" ? nameValue : void 0;
+};
+const toolInputOf = (event) => readField(readField(event, "toolCall"), "input");
+const contentText = (content) => {
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  let text = "";
+  for (const part of content) {
+    if (readField(part, "type") === "text") {
+      const value = readField(part, "text");
+      if (typeof value === "string") {
+        text += value;
+      }
+    }
+  }
+  return text.length > 0 ? text : void 0;
+};
+const describeError = (error) => {
+  if (error instanceof Error) {
+    return { message: error.message, name: error.name };
+  }
+  return error;
+};
+
+export { toolNameOf as a, describeToolOutcome as b, contentText as c, describeError as d, summarizeGatewayTelemetry as e, readField as r, summarizeUsage as s, toolInputOf as t };

package/dist/packem_shared/compileAgentWorkflow-DYFFyx7i.mjs

@@ -0,0 +1,78 @@
+import { defineWorkflow } from '@lunora/workflow';
+import { runAgentLoop } from './runAgentLoop-M8PKbtWT.mjs';
+import { createStreamGenerate, createAgentGenerate, createEpisodeExtract, createGraphExtract, createCompact } from './createAgentGenerate-DO7Z96zX.mjs';
+import { agentDefaultName } from '../naming.mjs';
+import { DEFAULT_AGENT_FUNCTION_PATHS } from './AGENT_MODULE-Dnt_-AAT.mjs';
+import { c as createDispatchRunner } from './createDispatchRunner-DSbp_dph-ZHTtxy3f.mjs';
+import { otlpTelemetry } from './otlpTelemetry-DU5ZmoEV.mjs';
+
+const resolveAgentRun = (contextRun, owner, env) => {
+  if (owner === void 0) {
+    return contextRun;
+  }
+  return createDispatchRunner({ env, identity: { userId: owner }, label: "@lunora/agent" });
+};
+
+const withAutoOtlpTelemetry = (agent, env, conversationId) => {
+  const endpoint = env.LUNORA_OTLP_ENDPOINT;
+  if (typeof endpoint !== "string" || endpoint === "" || agent.telemetry?.isEnabled === false) {
+    return agent;
+  }
+  const token = typeof env.LUNORA_OTLP_TOKEN === "string" ? env.LUNORA_OTLP_TOKEN : void 0;
+  const existingList = [agent.telemetry?.integrations].flat().filter((integration) => integration !== void 0);
+  return {
+    ...agent,
+    telemetry: {
+      ...agent.telemetry,
+      // Tag every generation span with the run's thread as its conversation
+      // id (one thread = one multi-turn conversation), so the cloud groups a
+      // deployed agent's turns with no app wiring. Absent → ungrouped, as before.
+      integrations: [...existingList, otlpTelemetry({ conversationId, endpoint, token })],
+      isEnabled: true
+    }
+  };
+};
+const compileAgentWorkflow = (agent, exportName, options) => defineWorkflow({
+  handler: async (context) => {
+    const runtimeAgent = withAutoOtlpTelemetry(agent, context.env, context.params.threadKey);
+    return runAgentLoop({
+      agent: runtimeAgent,
+      // Automatic history compaction. Dormant unless the agent declares
+      // a `compaction` config; the loop gates on it, so any other agent
+      // takes the byte-identical no-compaction path.
+      compact: createCompact(),
+      env: context.env,
+      exportName,
+      // Run-end graph extraction. Dormant unless the agent declares a
+      // `kind: "graph"` memory source AND the run carries an owner — the
+      // loop gates on both, so a semantic-only agent takes the
+      // byte-identical no-extraction path.
+      extractGraph: createGraphExtract(),
+      // Run-end episode recording. Dormant unless the agent declares a
+      // `kind: "episodic"` memory source AND the run carries an owner —
+      // the loop gates on both, so any other agent is byte-identical.
+      extractEpisode: createEpisodeExtract(),
+      generate: createAgentGenerate(runtimeAgent, context.env),
+      instanceId: context.event.instanceId,
+      params: context.params,
+      paths: options?.paths ?? DEFAULT_AGENT_FUNCTION_PATHS,
+      // The loop reads its own owner-gated thread back through
+      // `agents:*` queries. The default `context.run` forwards no
+      // identity, so on an OWNED thread those reads would come back
+      // empty and the model would answer blind. `resolveAgentRun`
+      // dispatches an owner-scoped run under that verified identity so
+      // the owner gate admits the loop's reads (ownerless runs keep the
+      // identity-free `context.run`). See `resolve-run.ts`.
+      run: resolveAgentRun(context.run, context.params.owner, context.env),
+      step: context.step,
+      // The streaming seam is wired and ready, but stays dormant until a
+      // live token sink is threaded onto the run (a follow-up wires
+      // `onTokenDelta` to the stream transport). With no sink the loop
+      // takes the byte-identical non-streaming `generate` path.
+      streamGenerate: createStreamGenerate(runtimeAgent, context.env)
+    });
+  },
+  name: agent.name ?? agentDefaultName(exportName)
+});
+
+export { compileAgentWorkflow as default };

package/dist/packem_shared/consoleTelemetry--3sWfu1R.mjs

@@ -0,0 +1,93 @@
+import { s as summarizeUsage, c as contentText, t as toolInputOf, d as describeError, r as readField, a as toolNameOf, b as describeToolOutcome } from './common-DQXayow6.mjs';
+
+const defaultLogger = (level, message, fields) => {
+  const target = globalThis.console;
+  if (level === "error") {
+    target.error(message, fields);
+  } else if (level === "warn") {
+    target.warn(message, fields);
+  } else {
+    target.info(message, fields);
+  }
+};
+const consoleTelemetry = (options = {}) => {
+  const { functionId, logger = defaultLogger, recordInputs = false, recordOutputs = false } = options;
+  const prefix = functionId === void 0 ? "" : `[${functionId}] `;
+  const log = (level, message, fields) => {
+    logger(level, `${prefix}${message}`, fields);
+  };
+  return {
+    onAbort: (event) => {
+      log("warn", "agent operation aborted", {
+        callId: readField(event, "callId"),
+        reason: readField(event, "reason")
+      });
+    },
+    onEnd: (event) => {
+      log("info", "agent operation completed", {
+        callId: readField(event, "callId"),
+        finishReason: readField(event, "finishReason"),
+        operationId: readField(event, "operationId"),
+        usage: summarizeUsage(readField(event, "usage"))
+      });
+    },
+    onError: (error) => {
+      log("error", "agent operation errored", { error: describeError(error) });
+    },
+    onLanguageModelCallEnd: (event) => {
+      const fields = {
+        callId: readField(event, "callId"),
+        finishReason: readField(event, "finishReason"),
+        modelId: readField(event, "modelId"),
+        provider: readField(event, "provider"),
+        usage: summarizeUsage(readField(event, "usage"))
+      };
+      if (recordOutputs) {
+        fields["text"] = contentText(readField(event, "content"));
+      }
+      log("info", "language model call ended", fields);
+    },
+    onStart: (event) => {
+      log("info", "agent operation started", {
+        callId: readField(event, "callId"),
+        modelId: readField(event, "modelId"),
+        operationId: readField(event, "operationId"),
+        provider: readField(event, "provider")
+      });
+    },
+    onStepEnd: (event) => {
+      log("info", "agent step ended", {
+        finishReason: readField(event, "finishReason"),
+        stepNumber: readField(event, "stepNumber"),
+        usage: summarizeUsage(readField(event, "usage"))
+      });
+    },
+    onStepStart: (event) => {
+      log("info", "agent step started", { stepNumber: readField(event, "stepNumber") });
+    },
+    onToolExecutionEnd: (event) => {
+      const outcome = describeToolOutcome(event);
+      const fields = {
+        success: outcome.success,
+        tool: outcome.name,
+        toolExecutionMs: outcome.toolExecutionMs
+      };
+      if (!outcome.success) {
+        fields["error"] = describeError(outcome.error);
+      }
+      if (recordOutputs && outcome.success) {
+        fields["output"] = outcome.output;
+      }
+      log(outcome.success ? "info" : "warn", "tool execution ended", fields);
+    },
+    onToolExecutionStart: (event) => {
+      const fields = { tool: toolNameOf(event) };
+      if (recordInputs) {
+        fields["input"] = toolInputOf(event);
+      }
+      log("info", "tool execution started", fields);
+    }
+  };
+};
+
+export { consoleTelemetry };

package/dist/packem_shared/createAgentContext-4xJGXNR4.mjs

@@ -0,0 +1,50 @@
+import { c as createDispatchRunner } from './createDispatchRunner-DSbp_dph-ZHTtxy3f.mjs';
+import { LunoraError } from '@lunora/errors';
+import { toFunctionReference, DEFAULT_AGENT_FUNCTION_PATHS } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const createAgentContext = (env, specs, dispatch) => {
+  const agents = {};
+  const patchThread = toFunctionReference(DEFAULT_AGENT_FUNCTION_PATHS.patchThread);
+  const resolveDispatch = () => dispatch ?? createDispatchRunner({ env, label: "@lunora/agent" });
+  for (const spec of specs) {
+    const resolve = () => {
+      const binding = env[spec.binding];
+      if (!binding || typeof binding.create !== "function" || typeof binding.get !== "function") {
+        throw new LunoraError(
+          "INTERNAL",
+          `@lunora/agent: no Workflow binding "${spec.binding}" on env for agent "${spec.exportName}" — run codegen/dev so wrangler.jsonc declares it`
+        );
+      }
+      return binding;
+    };
+    agents[spec.exportName] = {
+      cancel: async (id) => {
+        const instance = await resolve().get(id);
+        await instance.terminate();
+        try {
+          await resolveDispatch()(patchThread, { instanceId: id, status: "cancelled" });
+        } catch {
+        }
+      },
+      // Carried from the codegen spec (`defineAgent({ publicRun: true })`).
+      // Gates the public `agents:agentRun` mutation fail-closed; the
+      // server-side `run(...)` below is unaffected.
+      publicRun: spec.publicRun === true,
+      run: async (input, options) => {
+        const instance = await resolve().create({ ...options?.id === void 0 ? {} : { id: options.id }, params: input });
+        return { id: instance.id };
+      },
+      sendEvent: async (id, event) => {
+        const instance = await resolve().get(id);
+        await instance.sendEvent(event);
+      },
+      status: async (id) => {
+        const instance = await resolve().get(id);
+        return instance.status();
+      }
+    };
+  }
+  return agents;
+};
+
+export { createAgentContext as default };