@lunora/agent 1.0.0-alpha.1 → 1.0.0-alpha.100

package/dist/telemetry/index.d.ts

@@ -1,36 +1,41 @@
 import { Telemetry } from 'ai';
 /**
-* Privacy options shared by every telemetry integration in this package.
-*
-* Both flags default to **FALSE**. Without an explicit opt-in, no prompt,
-* message, tool input, generated model text, or tool output is ever forwarded
-* to a downstream tracer — only structural metadata (model id, finish reason,
-* token counts, tool name, timing, success/failure) is recorded. This is the
-* privacy-safe default: turn recording on deliberately, per integration.
-*/
+ * Privacy options shared by every telemetry integration in this package.
+ *
+ * Both flags default to **FALSE**. Without an explicit opt-in, no prompt,
+ * message, tool input, generated model text, or tool output is ever forwarded
+ * to a downstream tracer — only structural metadata (model id, finish reason,
+ * token counts, tool name, timing, success/failure) is recorded. This is the
+ * privacy-safe default: turn recording on deliberately, per integration.
+ * @experimental
+ */
 interface CommonOptions {
   /**
-  * When `true`, record model/tool **input** — prompts, messages, and tool
-  * call arguments. Default `false`.
-  */
+   * When `true`, record model/tool **input** — prompts, messages, and tool
+   * call arguments. Default `false`.
+   */
   recordInputs?: boolean;
   /**
-  * When `true`, record model/tool **output** — generated text and tool
-  * results. Default `false`.
-  */
+   * When `true`, record model/tool **output** — generated text and tool
+   * results. Default `false`.
+   */
   recordOutputs?: boolean;
 }
-/** The span handle a {@link BraintrustLike.traced} callback receives. */
+/**
+ * The span handle a {@link BraintrustLike.traced} callback receives.
+ * @experimental
+ */
 interface BraintrustSpan {
   /** Attach structured fields to the current span. */
   log: (event: Record<string, unknown>) => void;
 }
 /**
-* The minimal, **structural** slice of the `braintrust` SDK this bridge needs.
-* `braintrust` is intentionally **not** a dependency — the app passes its own
-* initialized logger, so this package stays dependency-free and works with any
-* compatible Braintrust SDK version.
-*/
+ * The minimal, **structural** slice of the `braintrust` SDK this bridge needs.
+ * `braintrust` is intentionally **not** a dependency — the app passes its own
+ * initialized logger, so this package stays dependency-free and works with any
+ * compatible Braintrust SDK version.
+ * @experimental
+ */
 interface BraintrustLike {
   /** Run `callback` inside a new traced span and return its result. */
   traced: <T>(callback: (span: BraintrustSpan) => T, args?: {
@@ -38,113 +43,331 @@ interface BraintrustLike {
     type?: string;
   }) => T;
 }
-/** Options for {@link braintrustTelemetry}. */
+/**
+ * Options for {@link braintrustTelemetry}.
+ * @experimental
+ */
 interface BraintrustTelemetryOptions extends CommonOptions {
   /** Span-name prefix for the language-model call (e.g. the agent name). */
   functionId?: string;
   /**
-  * The caller's initialized Braintrust logger (dependency-injected). Import
-  * and initialize `braintrust` in your app and pass it as `logger`.
-  */
+   * The caller's initialized Braintrust logger (dependency-injected). Import
+   * and initialize `braintrust` in your app and pass it as `logger`.
+   */
   logger: BraintrustLike;
 }
 /**
-* A dependency-injected Braintrust bridge for the ai@7 telemetry surface.
-*
-* It wraps model calls (`type: "llm"`) and tool executions (`type: "tool"`) in
-* `logger.traced` spans and logs structural metadata. Prompts / tool arguments
-* are logged only when `recordInputs` is set; generated text / tool results
-* only when `recordOutputs` is set. `onError` opens a span and logs the error.
-*
-* The app owns Braintrust initialization; pass the logger in as `logger`.
-*/
+ * A dependency-injected Braintrust bridge for the ai@7 telemetry surface.
+ *
+ * It wraps model calls (`type: "llm"`) and tool executions (`type: "tool"`) in
+ * `logger.traced` spans and logs structural metadata, including the call's token
+ * usage as Braintrust `metrics`. Prompts / tool arguments are logged only when
+ * `recordInputs` is set; generated text / tool results only when `recordOutputs`
+ * is set. `onError` opens a span and logs the error.
+ *
+ * The tool span is driven by the agent LOOP, not by `ai`: Lunora exposes tools
+ * schema-only so the SDK never executes one (see `telemetry/tool-execution.ts`).
+ *
+ * **A model-call span closes when the CALL ends, not when `execute()` resolves.**
+ * On a streamed turn `execute()` resolves the instant `doStream` hands back the
+ * stream — before a token, before any usage — so a span that simply awaited it
+ * measured time-to-first-byte and logged the stream handle instead of the
+ * generation. `execute()` still runs INSIDE the traced callback, which is what
+ * parents the provider's own work under the span; the callback then parks until
+ * the SDK's terminal event for that `callId` arrives, so `traced` finishes the
+ * span at the real end of the call, with the real usage. The caller gets
+ * `execute()`'s value the moment it resolves, exactly as before — the span's
+ * lifetime and the caller's are deliberately separate.
+ *
+ * The app owns Braintrust initialization; pass the logger in as `logger`.
+ * @experimental
+ */
 declare const braintrustTelemetry: (options: BraintrustTelemetryOptions) => Telemetry;
 /**
-* Combine several {@link Telemetry} integrations into a single one that fans
-* every lifecycle callback out to all of them and nests the two execution
-* wrappers so multiple span-context wrappers compose correctly.
-*
-* Value callbacks (`onStart`, `onStepEnd`, `onToolExecutionEnd`, …) invoke each
-* integration's matching callback (guarding `undefined`) and await them all in
-* parallel. The wrappers (`executeLanguageModelCall`, `executeTool`) are
-* composed by nesting right-to-left; integrations without a wrapper are skipped,
-* and with none defined the plain `execute` still runs.
-*/
+ * Combine several {@link Telemetry} integrations into a single one that fans
+ * every lifecycle callback out to all of them and nests the two execution
+ * wrappers so multiple span-context wrappers compose correctly.
+ *
+ * Value callbacks (`onStart`, `onStepEnd`, `onToolExecutionEnd`, …) invoke each
+ * integration's matching callback (guarding `undefined`) and await them all in
+ * parallel. The wrappers (`executeLanguageModelCall`, `executeTool`) are
+ * composed by nesting right-to-left; integrations without a wrapper are skipped,
+ * and with none defined the plain `execute` still runs.
+ * @experimental
+ */
 declare const combineTelemetry: (...integrations: Telemetry[]) => Telemetry;
-/** Severity level passed to a {@link ConsoleLogger}. */
+/**
+ * Severity level passed to a {@link ConsoleLogger}.
+ * @experimental
+ */
 type ConsoleLogLevel = "error" | "info" | "warn";
 /**
-* Structured log sink. Receives a level, a static human message, and a bag of
-* structured fields (never interpolated into the message, so log processors can
-* index them). The default sink writes to `globalThis.console`.
-*/
+ * Structured log sink. Receives a level, a static human message, and a bag of
+ * structured fields (never interpolated into the message, so log processors can
+ * index them). The default sink writes to `globalThis.console`.
+ * @experimental
+ */
 type ConsoleLogger = (level: ConsoleLogLevel, message: string, fields: Record<string, unknown>) => void;
-/** Options for {@link consoleTelemetry}. */
+/**
+ * Options for {@link consoleTelemetry}.
+ * @experimental
+ */
 interface ConsoleTelemetryOptions extends CommonOptions {
   /**
-  * Identifier prefixed into every log message (e.g. the agent name). Helps
-  * correlate lines when several agents share one process. Optional.
-  */
+   * Identifier prefixed into every log message (e.g. the agent name). Helps
+   * correlate lines when several agents share one process. Optional.
+   */
   functionId?: string;
   /**
-  * Sink for structured log lines. Defaults to a `globalThis.console`-backed
-  * writer that routes `info`/`warn`/`error` to the matching console method.
-  */
+   * Sink for structured log lines. Defaults to a `globalThis.console`-backed
+   * writer that routes `info`/`warn`/`error` to the matching console method.
+   */
   logger?: ConsoleLogger;
 }
 /**
-* A zero-dependency structured tracer for the ai@7 telemetry surface.
-*
-* It maps the generation lifecycle onto {@link ConsoleLogger} calls: operation
-* start/end, per-step start/end, model-call end (model + finish reason +
-* usage), and tool start/end (name, success, timing). By default it records
-* **only structural metadata** — set `recordInputs` to also log prompts / tool
-* arguments, and `recordOutputs` to log generated text / tool results.
-*
-* Every callback is defensive (event fields may be absent) and synchronous.
-*/
+ * A zero-dependency structured tracer for the ai@7 telemetry surface.
+ *
+ * It maps the generation lifecycle onto {@link ConsoleLogger} calls: operation
+ * start/end, per-step start/end, model-call end (model + finish reason +
+ * usage), and tool start/end (name, success, timing). By default it records
+ * **only structural metadata** — set `recordInputs` to also log prompts / tool
+ * arguments, and `recordOutputs` to log generated text / tool results.
+ *
+ * Every callback is defensive (event fields may be absent) and synchronous.
+ * @experimental
+ */
 declare const consoleTelemetry: (options?: ConsoleTelemetryOptions) => Telemetry;
 /**
-* The minimal, **structural** slice of `@sentry/cloudflare` (equivalently
-* `@sentry/node`/`@sentry/browser`) this bridge needs. `@sentry/cloudflare` is
-* intentionally **not** a dependency — the app passes its own already-initialized
-* Sentry namespace, so this package stays dependency-free and works with any
-* compatible Sentry SDK version.
-*/
+ * Options for {@link otlpTelemetry}.
+ * @experimental
+ */
+interface OtlpTelemetryOptions extends CommonOptions {
+  /**
+   * Conversation / session id to tag each generation span with, emitted as the
+   * `gen_ai.conversation.id` semantic-convention attribute so a multi-turn
+   * conversation's model turns group in the trace store. On a deployed agent the
+   * platform wiring passes the run's `threadKey` here automatically (one thread =
+   * one conversation). Omitted → the attribute is absent (backward-compatible),
+   * and each turn's span is ungrouped.
+   */
+  conversationId?: string;
+  /**
+   * The OTLP-over-HTTP collector base endpoint (e.g. the Lunora Cloud's `/v1`
+   * base). Spans are POSTed to `${endpoint}/v1/traces`; a trailing slash is
+   * tolerated. On the platform this is the injected `LUNORA_OTLP_ENDPOINT`.
+   */
+  endpoint: string;
+  /**
+   * Extra headers merged onto every POST — typically the correlation headers
+   * the platform injects. `Content-Type: application/json` is set by default.
+   */
+  headers?: Record<string, string>;
+  /** `service.name` resource attribute on every span. Defaults to `lunora`. */
+  serviceName?: string;
+  /**
+   * Bearer token added as `Authorization: Bearer` (wins over any authorization
+   * in `headers`) — the injected `LUNORA_OTLP_TOKEN`. Omit for an
+   * unauthenticated collector.
+   */
+  token?: string;
+  /**
+   * Trace id (32-hex) to hang every span of this run under, so one agent run
+   * reads as one trace. Pass a stable id derived from the run (e.g. the
+   * workflow run id). Omitted → each span mints its own trace id (still valid,
+   * just ungrouped).
+   */
+  traceId?: string;
+  /**
+   * The Worker request's `waitUntil`, so a fire-and-forget export survives
+   * isolate teardown after the turn returns. Omit and the send degrades to
+   * best-effort.
+   */
+  waitUntil?: (promise: Promise<unknown>) => void;
+}
+/**
+ * An OTLP-over-HTTP telemetry integration for `@lunora/agent`.
+ *
+ * The OTLP counterpart to the `sentryTelemetry` / `braintrustTelemetry` bridges:
+ * it records each language-model call and each tool execution as an OTLP **span**
+ * (`gen_ai.*` semantic-convention attributes — model, provider, token usage,
+ * tool name) and ships it to a collector, so agent generations land in the same
+ * trace store as the rest of an app's telemetry (the Lunora Cloud, or any OTel
+ * collector). Plug it into `defineAgent({ telemetry: { isEnabled: true,
+ * integrations: [otlpTelemetry({ endpoint, token })] } })`.
+ *
+ * **A model-call span closes when the CALL ends, not when `execute()` resolves.**
+ * On a streamed turn `execute()` resolves the instant `doStream` hands back the
+ * stream — before a single token, before any usage, and before any mid-stream
+ * failure. Closing the span there reported every voice and workflow-streamed turn
+ * as a ~1 ms, zero-token, always-OK call. So the span opens in
+ * `executeLanguageModelCall` (which also owns the failure path, since a rejected
+ * provider call produces no end event) and closes on `onLanguageModelCallEnd`,
+ * which the SDK fires once the response is normalized — after the stream's
+ * `finish` part, where the duration and the token usage actually live.
+ * `onError` / `onAbort` close whatever is still open, so a stream that dies or is
+ * barged in on reports a failure instead of a phantom success.
+ *
+ * **Tool spans come from the agent loop.** Lunora exposes tools to the model
+ * schema-only, so `ai` never runs one and never fires its tool telemetry; the
+ * loop calls `executeTool` itself from the durable step where the tool really
+ * runs (see `telemetry/tool-execution.ts`).
+ *
+ * One span per REAL execution: the agent loop memoizes each `step.do(...)`, so a
+ * Workflow replay returns the cached result without re-invoking the wrapped work
+ * and no duplicate span is emitted. Privacy-safe by default —
+ * `recordInputs`/`recordOutputs` both default `false`, so no prompt or generated
+ * text leaves the worker without an explicit opt-in; only structural metadata +
+ * token counts are recorded.
+ *
+ * Each export is fire-and-forget (registered with `waitUntil` when supplied);
+ * every rejection is swallowed so a flaky collector never surfaces to the run.
+ *
+ * One deliberate difference from the SDK-backed bridges, which delegate to a host
+ * tracer: flat, not nested. Every span gets `traceId` (shared when `traceId` is
+ * set) but no `parentSpanId`, so model-call and tool spans are siblings under the
+ * run rather than a tree — OTLP has no ambient span context to parent to here.
+ * @param options `endpoint` (+ optional `token`/`headers`/`serviceName`),
+ * `traceId` to group a run's spans, `waitUntil`, and the `recordInputs`/
+ * `recordOutputs` privacy flags.
+ * @experimental
+ */
+declare const otlpTelemetry: (options: OtlpTelemetryOptions) => Telemetry;
+/** The span context both `startSpan` and `startSpanManual` are called with. */
+interface SentrySpanContext {
+  attributes?: Record<string, unknown>;
+  name: string;
+  op?: string;
+}
+/**
+ * The subset of a Sentry `Span` this bridge drives. Structural, like
+ * {@link SentryLike} itself — a real `@sentry/*` span satisfies it.
+ * @experimental
+ */
+interface SentrySpan {
+  /** Finish the span. Called once, from whichever terminal event closes the call. */
+  end: () => void;
+  /** Attach attributes discovered after the span started (token usage). */
+  setAttributes?: (attributes: Record<string, unknown>) => unknown;
+  /** `1` = OK, `2` = ERROR (Sentry's `SPAN_STATUS_OK` / `SPAN_STATUS_ERROR`). */
+  setStatus?: (status: {
+    code: 0 | 1 | 2;
+    message?: string;
+  }) => unknown;
+}
+/**
+ * The minimal, **structural** slice of `@sentry/cloudflare` (equivalently
+ * `@sentry/node`/`@sentry/browser`) this bridge needs. `@sentry/cloudflare` is
+ * intentionally **not** a dependency — the app passes its own already-initialized
+ * Sentry namespace, so this package stays dependency-free and works with any
+ * compatible Sentry SDK version.
+ * @experimental
+ */
 interface SentryLike {
   /** Capture a thrown value / exception. */
   captureException: (exception: unknown) => unknown;
-  /** Run `callback` inside a new span and return its result. */
-  startSpan: <T>(context: {
-    attributes?: Record<string, unknown>;
-    name: string;
-    op?: string;
-  }, callback: (span: {
-    setStatus?: (status: {
-      code: number;
-    } | string) => void;
-  }) => T) => T;
+  /** Run `callback` inside a new span, finished when the callback settles. */
+  startSpan: <T>(context: SentrySpanContext, callback: (span: SentrySpan) => T) => T;
+  /**
+   * Run `callback` inside a new span that is **not** finished automatically —
+   * the caller owns its lifetime through `span.end()`. Present on every Sentry
+   * SDK built on `@sentry/core` (verified against `@sentry/core@10.55.0`); it is
+   * what lets a streamed model call be measured to the end of the stream while
+   * still nesting the provider's own work under it.
+   */
+  startSpanManual: <T>(context: SentrySpanContext, callback: (span: SentrySpan) => T) => T;
 }
-/** Options for {@link sentryTelemetry}. */
+/**
+ * Options for {@link sentryTelemetry}.
+ * @experimental
+ */
 interface SentryTelemetryOptions extends CommonOptions {
   /** Span-name prefix for the language-model call (e.g. the agent name). */
   functionId?: string;
   /**
-  * The caller's already-initialized Sentry namespace (dependency-injected).
-  * `import * as Sentry from "@sentry/cloudflare"` and pass it as `Sentry`.
-  */
+   * The caller's already-initialized Sentry namespace (dependency-injected).
+   * `import * as Sentry from "@sentry/cloudflare"` and pass it as `Sentry`.
+   */
   Sentry: SentryLike;
 }
 /**
-* A dependency-injected Sentry bridge for the ai@7 telemetry surface.
-*
-* It wraps model calls and tool executions in Sentry spans (via
-* `Sentry.startSpan`) so nested provider/tool work is correctly parented, and
-* routes `onError` to `Sentry.captureException`. Span attributes carry only
-* structural metadata (model, provider, tool name) unless `recordInputs` is
-* set, in which case prompts / tool arguments are attached too.
-*
-* The app owns Sentry initialization; pass the namespace in as `Sentry`.
-*/
+ * A dependency-injected Sentry bridge for the ai@7 telemetry surface.
+ *
+ * It wraps model calls and tool executions in Sentry spans so nested
+ * provider/tool work is correctly parented, and routes `onError` to
+ * `Sentry.captureException`. Span attributes carry only structural metadata
+ * (model, provider, tool name, token usage) unless `recordInputs` /
+ * `recordOutputs` are set, in which case prompts, tool arguments and generated
+ * text are attached too.
+ *
+ * The tool span is driven by the agent LOOP, not by `ai`: Lunora exposes tools
+ * schema-only so the SDK never executes one (see `telemetry/tool-execution.ts`).
+ *
+ * **A model-call span closes when the CALL ends, not when `execute()` resolves.**
+ * On a streamed turn `execute()` resolves the instant `doStream` hands back the
+ * stream — before a token, before any usage. The span still OPENS around
+ * `execute()`, because that is what makes it the active span nested provider work
+ * parents to, but it is opened with `startSpanManual` and so is not finished
+ * there: `onLanguageModelCallEnd` ends it, once the response is normalized and
+ * the real duration and token usage are both known. `onAbort` / `onError` end the
+ * call they name as a failure, so a stream that dies or is barged in on reports
+ * one instead of a phantom success.
+ *
+ * The app owns Sentry initialization; pass the namespace in as `Sentry`.
+ * @experimental
+ */
 declare const sentryTelemetry: (options: SentryTelemetryOptions) => Telemetry;
-export { type BraintrustLike, type BraintrustSpan, type BraintrustTelemetryOptions, type CommonOptions, type ConsoleLogLevel, type ConsoleLogger, type ConsoleTelemetryOptions, type SentryLike, type SentryTelemetryOptions, braintrustTelemetry, combineTelemetry, consoleTelemetry, sentryTelemetry };
+export {
+/**
+ * `@lunora/agent/telemetry` — observability integrations for `@lunora/agent`.
+ *
+ * Every export here produces an ai@7 `Telemetry` object suitable for the
+ * `integrations` array of `TelemetryOptions` (`defineAgent({ telemetry: {
+ * isEnabled: true, integrations: [...] } })`). `consoleTelemetry` is a
+ * zero-dependency structured console tracer; `combineTelemetry` fans the
+ * lifecycle out to several integrations and nests their execution wrappers;
+ * `sentryTelemetry` / `braintrustTelemetry` are dependency-injected bridges (the
+ * app passes its own Sentry namespace / Braintrust logger, so the heavy SDKs are
+ * never imported here); and `otlpTelemetry` ships `gen_ai.*` spans over
+ * OTLP-over-HTTP to any collector (the Lunora Cloud, or your own), so agent
+ * generations land in the same trace store as the rest of the app.
+ *
+ * All integrations are privacy-safe by default (`recordInputs` / `recordOutputs`
+ * both default `false`), so nothing sensitive is recorded without opt-in.
+ */
+type BraintrustLike,
+/**
+ * `@lunora/agent/telemetry` — observability integrations for `@lunora/agent`.
+ *
+ * Every export here produces an ai@7 `Telemetry` object suitable for the
+ * `integrations` array of `TelemetryOptions` (`defineAgent({ telemetry: {
+ * isEnabled: true, integrations: [...] } })`). `consoleTelemetry` is a
+ * zero-dependency structured console tracer; `combineTelemetry` fans the
+ * lifecycle out to several integrations and nests their execution wrappers;
+ * `sentryTelemetry` / `braintrustTelemetry` are dependency-injected bridges (the
+ * app passes its own Sentry namespace / Braintrust logger, so the heavy SDKs are
+ * never imported here); and `otlpTelemetry` ships `gen_ai.*` spans over
+ * OTLP-over-HTTP to any collector (the Lunora Cloud, or your own), so agent
+ * generations land in the same trace store as the rest of the app.
+ *
+ * All integrations are privacy-safe by default (`recordInputs` / `recordOutputs`
+ * both default `false`), so nothing sensitive is recorded without opt-in.
+ */
+type BraintrustSpan,
+/**
+ * `@lunora/agent/telemetry` — observability integrations for `@lunora/agent`.
+ *
+ * Every export here produces an ai@7 `Telemetry` object suitable for the
+ * `integrations` array of `TelemetryOptions` (`defineAgent({ telemetry: {
+ * isEnabled: true, integrations: [...] } })`). `consoleTelemetry` is a
+ * zero-dependency structured console tracer; `combineTelemetry` fans the
+ * lifecycle out to several integrations and nests their execution wrappers;
+ * `sentryTelemetry` / `braintrustTelemetry` are dependency-injected bridges (the
+ * app passes its own Sentry namespace / Braintrust logger, so the heavy SDKs are
+ * never imported here); and `otlpTelemetry` ships `gen_ai.*` spans over
+ * OTLP-over-HTTP to any collector (the Lunora Cloud, or your own), so agent
+ * generations land in the same trace store as the rest of the app.
+ *
+ * All integrations are privacy-safe by default (`recordInputs` / `recordOutputs`
+ * both default `false`), so nothing sensitive is recorded without opt-in.
+ */
+type BraintrustTelemetryOptions, type CommonOptions, type ConsoleLogLevel, type ConsoleLogger, type ConsoleTelemetryOptions, type OtlpTelemetryOptions, type SentryLike, type SentrySpan, type SentryTelemetryOptions, braintrustTelemetry, combineTelemetry, consoleTelemetry, otlpTelemetry, sentryTelemetry };

package/dist/telemetry/index.mjs

@@ -1,4 +1 @@
-export { braintrustTelemetry } from '../packem_shared/braintrustTelemetry-wuGDErob.mjs';
-export { combineTelemetry } from '../packem_shared/combineTelemetry-DCyaaWAI.mjs';
-export { consoleTelemetry } from '../packem_shared/consoleTelemetry-z2MiP1jt.mjs';
-export { sentryTelemetry } from '../packem_shared/sentryTelemetry-CgqFJyLO.mjs';
+import{braintrustTelemetry as o}from"../packem_shared/braintrustTelemetry-Byne8uPK.mjs";import{combineTelemetry as m}from"../packem_shared/combineTelemetry-DgE9W9G8.mjs";import{consoleTelemetry as p}from"../packem_shared/consoleTelemetry-BZY3Y-Ly.mjs";import{otlpTelemetry as f}from"../packem_shared/otlpTelemetry-ByqrB-72.mjs";import{sentryTelemetry as T}from"../packem_shared/sentryTelemetry-BHeydiAB.mjs";export{o as braintrustTelemetry,m as combineTelemetry,p as consoleTelemetry,f as otlpTelemetry,T as sentryTelemetry};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/agent",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.100",
   "description": "Durable AI agents for Lunora: defineAgent compiles a replay-safe tool-loop onto Cloudflare Workflows, with DO SQLite threads and live message subscriptions",
   "keywords": [
     "agent",
@@ -62,6 +62,14 @@
       "types": "./dist/naming.d.ts",
       "import": "./dist/naming.mjs"
     },
+    "./skill-markdown": {
+      "types": "./dist/skill-markdown.d.ts",
+      "import": "./dist/skill-markdown.mjs"
+    },
+    "./reply": {
+      "types": "./dist/reply.d.ts",
+      "import": "./dist/reply.mjs"
+    },
     "./sandbox": {
       "types": "./dist/sandbox.d.ts",
       "import": "./dist/sandbox.mjs"
@@ -76,14 +84,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/ai": "1.0.0-alpha.14",
-    "@lunora/errors": "1.0.0-alpha.4",
-    "@lunora/mail": "1.0.0-alpha.14",
-    "@lunora/server": "1.0.0-alpha.24",
-    "@lunora/values": "1.0.0-alpha.7",
-    "@lunora/workflow": "1.0.0-alpha.9",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "ai": "7.0.16"
+    "@lunora/ai": "1.0.0-alpha.82",
+    "@lunora/errors": "1.0.0-alpha.35",
+    "@lunora/mail": "1.0.0-alpha.72",
+    "@lunora/server": "1.0.0-alpha.113",
+    "@lunora/values": "1.0.0-alpha.43",
+    "@lunora/workflow": "1.0.0-alpha.49",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "ai": "7.0.93",
+    "yaml": "^2.9.0"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"

package/dist/packem_shared/AGENT_MODULE-Dnt_-AAT.mjs

@@ -1,24 +0,0 @@
-const AGENT_MODULE = "agents";
-const SANDBOX_MODULE = "sandbox";
-const SANDBOX_INVOKE_PATH = `${SANDBOX_MODULE}:invoke`;
-const DEFAULT_AGENT_FUNCTION_PATHS = {
-  appendMessage: `${AGENT_MODULE}:agentAppendMessage`,
-  ensureThread: `${AGENT_MODULE}:agentEnsureThread`,
-  episodeRecall: `${AGENT_MODULE}:agentEpisodeRecall`,
-  episodeUpsert: `${AGENT_MODULE}:agentEpisodeUpsert`,
-  graphTraverse: `${AGENT_MODULE}:agentGraphTraverse`,
-  graphUpsert: `${AGENT_MODULE}:agentGraphUpsert`,
-  listMessages: `${AGENT_MODULE}:agentMessages`,
-  patchThread: `${AGENT_MODULE}:agentPatchThread`,
-  run: `${AGENT_MODULE}:agentRun`,
-  setState: `${AGENT_MODULE}:agentSetState`,
-  state: `${AGENT_MODULE}:agentState`
-};
-const toFunctionReference = (source) => {
-  if (typeof source === "string") {
-    return { __lunoraRef: source };
-  }
-  return source;
-};
-
-export { AGENT_MODULE, DEFAULT_AGENT_FUNCTION_PATHS, SANDBOX_INVOKE_PATH, SANDBOX_MODULE, toFunctionReference };