@plasm_lang/vercel-agent 0.3.123 → 0.3.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasm_lang/vercel-agent",
-  "version": "0.3.123",
+  "version": "0.3.125",
   "description": "Catalog-native TypeScript agent framework (Plasm CGS/CML, Vercel AI SDK, Nitro-oriented)",
   "license": "GPL-3.0-or-later",
   "repository": {
@@ -65,7 +65,7 @@
   "dependencies": {
     "@ai-sdk/otel": "1.0.14",
     "@opentelemetry/api": "^1.9.0",
-    "@plasm_lang/engine": "^0.3.123",
+    "@plasm_lang/engine": "^0.3.125",
     "@vercel/blob": "^0.27.3",
     "@vercel/connect": "^0.2.6",
     "@vercel/kv": "^3.0.0",

package/src/index.ts

@@ -158,6 +158,7 @@ export type {
 export {
   PlasmSpanAttributes,
   createAgentTelemetry,
+  ensureOtelIntegration,
   registerAgentInstrumentation,
 } from "./instrumentation.js";
 export type { AgentInstrumentationOptions } from "./instrumentation.js";

package/src/instrumentation.ts

@@ -1,9 +1,5 @@
-import { LegacyOpenTelemetry } from "@ai-sdk/otel";
-import {
-  registerTelemetry,
-  type Telemetry,
-  type TelemetryOptions,
-} from "ai";
+import { OpenTelemetry } from "@ai-sdk/otel";
+import { registerTelemetry, type TelemetryOptions } from "ai";
 
 /** OpenTelemetry attribute keys for Plasm agent spans (Section 9). */
 export const PlasmSpanAttributes = {
@@ -25,27 +21,29 @@ export interface AgentInstrumentationOptions {
 
 let registered = false;
 
-function otelIntegration(_options: AgentInstrumentationOptions): Telemetry {
-  return new LegacyOpenTelemetry();
+/** Register global AI SDK OTEL integration (Eve uses OpenTelemetry + runtimeContext). */
+export function ensureOtelIntegration(): void {
+  if (registered) return;
+  registerTelemetry(new OpenTelemetry({ runtimeContext: true }));
+  registered = true;
 }
 
 /** Register global AI SDK OTEL integration (eve-style auto-discovered instrumentation). */
 export function registerAgentInstrumentation(
   options: AgentInstrumentationOptions = {},
 ): void {
-  if (registered) return;
-  registerTelemetry(otelIntegration(options));
-  registered = true;
+  ensureOtelIntegration();
   void options.serviceName;
 }
 
-/** Per-call AI SDK telemetry settings with OpenTelemetry integration. */
+/** Per-call AI SDK telemetry settings (OTEL registered in agent/instrumentation.ts). */
 export function createAgentTelemetry(
   options: AgentInstrumentationOptions = {},
 ): TelemetryOptions {
-  registerAgentInstrumentation(options);
   return {
     isEnabled: true,
     functionId: options.serviceName ?? "plasm-agent",
+    recordInputs: true,
+    recordOutputs: true,
   };
 }

package/src/nitro/agent-summary.ts

@@ -7,10 +7,11 @@ import { exportScheduleTaskManifest } from "../authoring/schedule-manager.js";
 import type { AgentDefinition } from "../define-agent.js";
 import type { ProjectDiscovery } from "../discovery/project-walker.js";
 import { frameworkPackageVersion } from "../package-version.js";
-import { plasmAgentSummaryPath } from "./paths.js";
+import { plasmAgentSummaryPath, eveAgentSummaryPath } from "./paths.js";
 
 export const VERCEL_PLASM_AGENT_SUMMARY_KIND = "vercel-plasm-agent-summary";
 export const VERCEL_PLASM_AGENT_SUMMARY_VERSION = 3;
+export const VERCEL_EVE_AGENT_SUMMARY_KIND = "vercel-eve-agent-summary";
 
 export interface PlasmAgentSummaryPayload {
   kind: typeof VERCEL_PLASM_AGENT_SUMMARY_KIND;
@@ -131,3 +132,61 @@ export async function emitPlasmAgentSummary(options: {
   await writeFile(outPath, `${JSON.stringify(options.summary, null, 2)}\n`, "utf8");
   return outPath;
 }
+
+function mapSkillSourceKind(sourceKind: string): "markdown" | "module" | "skill-package" {
+  if (sourceKind === "markdown") return "markdown";
+  if (sourceKind === "skill-package") return "skill-package";
+  return "module";
+}
+
+/** Eve-compatible summary for Vercel Agent Runs build ingestion (`.eve/agent-summary.json`). */
+export function toEveAgentSummary(
+  summary: PlasmAgentSummaryPayload,
+  instructionsMarkdown?: string | null,
+): Record<string, unknown> {
+  return {
+    kind: VERCEL_EVE_AGENT_SUMMARY_KIND,
+    schemaVersion: VERCEL_PLASM_AGENT_SUMMARY_VERSION,
+    generatorVersion: summary.generatorVersion,
+    agent: {
+      name: summary.agent.name,
+      ...(summary.agent.description ? { description: summary.agent.description } : {}),
+      modelId: summary.agent.modelId,
+    },
+    instructions: summary.instructions
+      ? {
+          logicalPath: summary.instructions.logicalPath,
+          sourceKind: summary.instructions.sourceKind === "markdown" ? "markdown" : "module",
+          markdown: instructionsMarkdown ?? summary.instructions.markdown ?? "",
+        }
+      : null,
+    schedules: summary.schedules,
+    tools: summary.tools,
+    skills: summary.skills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      logicalPath: skill.logicalPath,
+      sourceKind: mapSkillSourceKind(skill.sourceKind),
+    })),
+    connections: summary.connections,
+    channels: summary.channels,
+    sandbox: summary.sandbox,
+    subagents: summary.subagents,
+    diagnostics: summary.diagnostics,
+  };
+}
+
+export async function emitEveCompatibleAgentSummary(options: {
+  projectRoot: string;
+  summary: PlasmAgentSummaryPayload;
+  instructionsMarkdown?: string | null;
+}): Promise<string> {
+  const outPath = eveAgentSummaryPath(options.projectRoot);
+  await mkdir(path.dirname(outPath), { recursive: true });
+  await writeFile(
+    outPath,
+    `${JSON.stringify(toEveAgentSummary(options.summary, options.instructionsMarkdown), null, 2)}\n`,
+    "utf8",
+  );
+  return outPath;
+}

package/src/nitro/build-application.ts

@@ -1,9 +1,14 @@
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 
 import type { CompiledSlotMap } from "../cli/compile-authored-slots.js";
 import { loadAuthoredSlots } from "../authoring/slot-loader.js";
 import type { ProjectDiscovery } from "../discovery/project-walker.js";
-import { buildPlasmAgentSummary, emitPlasmAgentSummary } from "./agent-summary.js";
+import {
+  buildPlasmAgentSummary,
+  emitEveCompatibleAgentSummary,
+  emitPlasmAgentSummary,
+} from "./agent-summary.js";
 import { buildNitroOutput } from "./build-nitro-output.js";
 import { createPlasmNitro } from "./create-plasm-nitro.js";
 import { patchVercelOutputConfig } from "./patch-vercel-config.js";
@@ -18,6 +23,7 @@ import { writeWorkflowDispatchRoute } from "./write-workflow-dispatch-route.js";
 export interface PlasmApplicationBuildResult {
   outputDir: string;
   agentSummaryPath: string;
+  eveAgentSummaryPath: string;
   vercelOutput: boolean;
 }
 
@@ -85,12 +91,27 @@ export async function buildPlasmApplication(options: {
     });
     const agentSummaryPath = await emitPlasmAgentSummary({ projectRoot, summary });
 
+    let instructionsMarkdown: string | null = null;
+    if (discovery.instructions?.path) {
+      try {
+        instructionsMarkdown = await readFile(discovery.instructions.path, "utf8");
+      } catch {
+        instructionsMarkdown = null;
+      }
+    }
+    const eveAgentSummaryPath = await emitEveCompatibleAgentSummary({
+      projectRoot,
+      summary,
+      instructionsMarkdown,
+    });
+
     const vercelOutput = isVercelBuildEnvironment();
     const resolvedOutput = vercelOutput ? vercelOutputDir(projectRoot) : outputDir;
 
     return {
       outputDir: resolvedOutput,
       agentSummaryPath,
+      eveAgentSummaryPath,
       vercelOutput,
     };
   } finally {

package/src/nitro/paths.ts

@@ -4,6 +4,7 @@ export const PLASM_NITRO_BUILD_DIR = ".plasm/nitro";
 export const PLASM_NITRO_ROUTES_DIR = ".plasm/nitro/routes";
 export const PLASM_NITRO_OUTPUT_DIR = ".plasm/nitro-output";
 export const PLASM_AGENT_SUMMARY_PATH = ".plasm/agent-summary.json";
+export const EVE_AGENT_SUMMARY_PATH = ".eve/agent-summary.json";
 
 export function plasmNitroBuildDir(projectRoot: string): string {
   return path.join(projectRoot, PLASM_NITRO_BUILD_DIR);
@@ -21,6 +22,10 @@ export function plasmAgentSummaryPath(projectRoot: string): string {
   return path.join(projectRoot, PLASM_AGENT_SUMMARY_PATH);
 }
 
+export function eveAgentSummaryPath(projectRoot: string): string {
+  return path.join(projectRoot, EVE_AGENT_SUMMARY_PATH);
+}
+
 export function vercelOutputDir(projectRoot: string): string {
   return path.join(projectRoot, ".vercel", "output");
 }

package/src/runtime/plasm-agent.ts

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 
-import { generateText, stepCountIs, type LanguageModel, type ModelMessage, type ToolSet } from "ai";
+import { type LanguageModel, type ModelMessage, type ToolSet } from "ai";
 
 import type {
   AgentBuildConfig,
@@ -19,10 +19,16 @@ import { maybeCompactMessages } from "../runtime/compaction.js";
 import { AgentRuntime, type AgentRuntimeConfig } from "../runtime/agent-runtime.js";
 import { createHarnessTools, renderSkillIndex } from "../tools/harness-tools.js";
 import { createPlasmTools } from "../tools/plasm-tools.js";
+import { runEveToolLoop, type AgentStepEvent } from "../telemetry/eve-tool-loop.js";
+import type { EveChannelKind } from "../telemetry/eve-agent-runs.js";
+
+export type { AgentStepEvent };
 
 export interface PlasmAgentConfig extends AgentRuntimeConfig {
   /** AI Gateway model slug, e.g. `anthropic/claude-sonnet-4.6`. */
   model: string | LanguageModel;
+  /** Agent Runs / OTEL function id (defaults from agent root directory name). */
+  agentName?: string;
   instructionsPath?: string;
   maxSteps?: number;
   telemetry?: boolean;
@@ -36,22 +42,18 @@ export interface PlasmAgentConfig extends AgentRuntimeConfig {
   getAuthoringContext?: () => AuthoringContext;
 }
 
-export interface AgentStepEvent {
-  toolCalls?: Array<{ toolName: string }>;
-  text?: string;
-  finishReason?: string;
-}
-
 export interface AgentGenerateOptions {
   messages?: ModelMessage[];
   resetConversation?: boolean;
   onStepFinish?: (step: AgentStepEvent) => void | Promise<void>;
+  /** Eve Agent Runs channel kind (`schedule`, `http`, `channel:<name>`, …). */
+  channelKind?: EveChannelKind;
 }
 
 export interface AgentTurnResult {
   text: string;
   steps: unknown[];
-  usage: Awaited<ReturnType<typeof generateText>>["usage"];
+  usage: Awaited<ReturnType<typeof runEveToolLoop>>["usage"];
 }
 
 export class PlasmAgent {
@@ -67,6 +69,7 @@ export class PlasmAgent {
   private readonly hookRunner?: HookRunner;
   private readonly subagentRegistry?: SubagentRegistry;
   private readonly getAuthoringContext?: () => AuthoringContext;
+  private readonly agentName: string;
   private conversation: ModelMessage[] = [];
 
   constructor(config: PlasmAgentConfig) {
@@ -77,6 +80,10 @@ export class PlasmAgent {
       config.instructionsPath ?? path.join(config.agentRoot, "instructions.md");
     this.maxSteps = config.maxSteps ?? 20;
     this.telemetryEnabled = config.telemetry ?? true;
+    this.agentName =
+      config.agentName?.trim() ||
+      process.env.PLASM_AGENT_NAME?.trim() ||
+      path.basename(path.dirname(config.agentRoot));
     this.loadedSkills = config.loadedSkills ?? [];
     this.compaction = config.compaction;
     const skillsFlag = config.experimental?.skills;
@@ -142,7 +149,7 @@ export class PlasmAgent {
     } as ToolSet;
 
     const telemetry = this.telemetryEnabled
-      ? createAgentTelemetry({ serviceName: "plasm-agent" })
+      ? createAgentTelemetry({ serviceName: this.agentName })
       : { isEnabled: false };
     const model = resolveGatewayModel(this.model, this.modelOptions);
 
@@ -160,31 +167,24 @@ export class PlasmAgent {
 
     messages = await maybeCompactMessages(messages, this.compaction, this.model);
 
-    const generation = {
+    const onStepFinish = async (step: AgentStepEvent) => {
+      await options.onStepFinish?.(step);
+      if (!this.hookRunner || !this.getAuthoringContext) return;
+      const toolsUsed = (step.toolCalls ?? []).map((call) => call.toolName);
+      await this.hookRunner.emit("agent:step", this.getAuthoringContext(), { toolsUsed });
+    };
+
+    const result = await runEveToolLoop({
       model,
       system,
       tools,
-      stopWhen: stepCountIs(this.maxSteps),
-      experimental_telemetry: telemetry,
-      onStepFinish: async (step: AgentStepEvent) => {
-        await options.onStepFinish?.(step);
-        if (!this.hookRunner || !this.getAuthoringContext) return;
-        const toolsUsed = (step.toolCalls ?? []).map((call) => call.toolName);
-        await this.hookRunner.emit("agent:step", this.getAuthoringContext(), { toolsUsed });
-      },
-      ...(this.modelOptions?.temperature !== undefined
-        ? { temperature: this.modelOptions.temperature }
-        : {}),
-      ...(this.modelOptions?.maxOutputTokens !== undefined
-        ? { maxOutputTokens: this.modelOptions.maxOutputTokens }
-        : {}),
-      ...(this.modelOptions?.topP !== undefined ? { topP: this.modelOptions.topP } : {}),
-      ...(this.modelOptions?.topK !== undefined ? { topK: this.modelOptions.topK } : {}),
-    };
-
-    const result = await generateText({
-      ...generation,
       messages,
+      maxSteps: this.maxSteps,
+      agentName: this.agentName,
+      channelKind: options.channelKind,
+      telemetry,
+      onStepFinish,
+      modelOptions: this.modelOptions,
     });
 
     if (!externalMessages) {

package/src/telemetry/eve-agent-runs.ts

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import type { TelemetryOptions } from "ai";
+
+import { frameworkPackageVersion } from "../package-version.js";
+
+const EVE_TRACER_NAME = "eve";
+
+export type EveChannelKind = string;
+
+export interface EveEmissionState {
+  sessionId: string;
+  turnId: string;
+  sequence: number;
+  stepIndex: number;
+  channelKind: EveChannelKind;
+}
+
+function eveEnvironment(): string {
+  return process.env.VERCEL_ENV?.trim() || process.env.NODE_ENV?.trim() || "development";
+}
+
+/** Session id for one agent turn — matches Eve `eve.session.id` on Agent Runs spans. */
+export function createEveSessionId(): string {
+  return randomUUID();
+}
+
+/** Turn id inside a session (Eve default: `turn_0`, `turn_1`, …). */
+export function createEveTurnId(sequence: number): string {
+  return `turn_${sequence}`;
+}
+
+/** Runtime context keys Vercel Agent Runs reads from AI SDK spans. */
+export function buildEveRuntimeContext(state: EveEmissionState): Record<string, string> {
+  return {
+    "eve.version": frameworkPackageVersion(),
+    "eve.environment": eveEnvironment(),
+    "eve.session.id": state.sessionId,
+    "eve.turn.id": state.turnId,
+    "eve.turn.sequence": String(state.sequence),
+    "eve.step.index": String(state.stepIndex),
+    "eve.channel.kind": state.channelKind,
+  };
+}
+
+/** Eve-style telemetry options: record I/O + propagate runtime context onto spans. */
+export function enrichEveTelemetry(
+  base: TelemetryOptions,
+  runtimeContext: Record<string, string>,
+): TelemetryOptions {
+  const includeRuntimeContext: Record<string, boolean> = {};
+  for (const key of Object.keys(runtimeContext)) {
+    includeRuntimeContext[key] = true;
+  }
+  return {
+    ...base,
+    isEnabled: base.isEnabled ?? true,
+    recordInputs: base.recordInputs ?? true,
+    recordOutputs: base.recordOutputs ?? true,
+    includeRuntimeContext,
+  };
+}
+
+export interface EveTurnSpanOptions extends EveEmissionState {
+  functionId?: string;
+  attributes?: Record<string, string | number | boolean>;
+}
+
+function eveTurnSpanAttributes(options: EveTurnSpanOptions): Record<string, string | number | boolean> {
+  return {
+    "eve.version": frameworkPackageVersion(),
+    "eve.environment": eveEnvironment(),
+    "eve.session.id": options.sessionId,
+    "eve.turn.id": options.turnId,
+    "eve.turn.sequence": options.sequence,
+    "eve.step.index": options.stepIndex,
+    "eve.channel.kind": options.channelKind,
+    ...(options.functionId ? { "ai.telemetry.functionId": options.functionId } : {}),
+    ...options.attributes,
+  };
+}
+
+/**
+ * Parent span Vercel Agent Runs ingests (`ai.eve.turn` + `eve.session.id`).
+ * Eve emits one per tool-loop step; Plasm matches that shape.
+ */
+export async function withEveTurnSpan<T>(
+  options: EveTurnSpanOptions,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const tracer = trace.getTracer(EVE_TRACER_NAME);
+  const attributes = eveTurnSpanAttributes(options);
+
+  return tracer.startActiveSpan("ai.eve.turn", { attributes }, async (span) => {
+    try {
+      return await fn();
+    } catch (err) {
+      span.setStatus({ code: SpanStatusCode.ERROR, message: String(err) });
+      throw err;
+    }
+  });
+}

package/src/telemetry/eve-tool-loop.ts

@@ -0,0 +1,145 @@
+import {
+  streamText,
+  stepCountIs,
+  type LanguageModel,
+  type LanguageModelUsage,
+  type ModelMessage,
+  type TelemetryOptions,
+  type ToolSet,
+} from "ai";
+import type { Context } from "@ai-sdk/provider-utils";
+
+import { ensureOtelIntegration } from "../instrumentation.js";
+import {
+  buildEveRuntimeContext,
+  createEveSessionId,
+  createEveTurnId,
+  enrichEveTelemetry,
+  withEveTurnSpan,
+  type EveChannelKind,
+} from "./eve-agent-runs.js";
+
+export interface AgentStepEvent {
+  toolCalls?: Array<{ toolName: string }>;
+  text?: string;
+  finishReason?: string;
+}
+
+export interface EveToolLoopModelOptions {
+  temperature?: number;
+  maxOutputTokens?: number;
+  topP?: number;
+  topK?: number;
+}
+
+export interface EveToolLoopOptions {
+  model: LanguageModel;
+  system: string;
+  tools: ToolSet;
+  messages: ModelMessage[];
+  maxSteps: number;
+  agentName: string;
+  channelKind?: EveChannelKind;
+  telemetry?: TelemetryOptions;
+  onStepFinish?: (step: AgentStepEvent) => void | Promise<void>;
+  modelOptions?: EveToolLoopModelOptions;
+}
+
+export interface EveToolLoopResult {
+  text: string;
+  steps: unknown[];
+  usage: LanguageModelUsage;
+}
+
+/**
+ * Eve-compatible tool loop: one `ai.eve.turn` parent span per step, `streamText`
+ * child spans via AI SDK OTEL (`OpenTelemetry` + runtime context).
+ */
+export async function runEveToolLoop(options: EveToolLoopOptions): Promise<EveToolLoopResult> {
+  ensureOtelIntegration();
+
+  const sessionId = createEveSessionId();
+  const turnId = createEveTurnId(0);
+  const channelKind = options.channelKind ?? "unknown";
+
+  let messages = options.messages;
+  let stepIndex = 0;
+  let finalText = "";
+  let lastUsage: LanguageModelUsage | undefined;
+  const aggregatedSteps: unknown[] = [];
+
+  while (stepIndex < options.maxSteps) {
+    const runtimeContext = buildEveRuntimeContext({
+      sessionId,
+      turnId,
+      sequence: 0,
+      stepIndex,
+      channelKind,
+    });
+    const telemetry = enrichEveTelemetry(
+      options.telemetry ?? { isEnabled: true, functionId: options.agentName },
+      runtimeContext,
+    );
+
+    const stepResult = await withEveTurnSpan(
+      {
+        sessionId,
+        turnId,
+        sequence: 0,
+        stepIndex,
+        channelKind,
+        functionId: options.agentName,
+      },
+      async () => {
+        const streamResult = streamText({
+          model: options.model,
+          system: options.system,
+          tools: options.tools,
+          messages,
+          stopWhen: stepCountIs(1),
+          runtimeContext: runtimeContext as Context,
+          experimental_telemetry: telemetry,
+          onStepFinish: options.onStepFinish,
+          ...(options.modelOptions?.temperature !== undefined
+            ? { temperature: options.modelOptions.temperature }
+            : {}),
+          ...(options.modelOptions?.maxOutputTokens !== undefined
+            ? { maxOutputTokens: options.modelOptions.maxOutputTokens }
+            : {}),
+          ...(options.modelOptions?.topP !== undefined ? { topP: options.modelOptions.topP } : {}),
+          ...(options.modelOptions?.topK !== undefined ? { topK: options.modelOptions.topK } : {}),
+        });
+
+        const [text, finishReason, steps, usage, response] = await Promise.all([
+          streamResult.text,
+          streamResult.finishReason,
+          streamResult.steps,
+          streamResult.usage,
+          streamResult.response,
+        ]);
+
+        return { text, finishReason, steps, usage, response };
+      },
+    );
+
+    finalText = stepResult.text;
+    lastUsage = stepResult.usage;
+    aggregatedSteps.push(...stepResult.steps);
+    messages = stepResult.response.messages as ModelMessage[];
+
+    stepIndex += 1;
+    if (stepResult.finishReason !== "tool-calls") {
+      break;
+    }
+  }
+
+  if (!lastUsage) {
+    throw new Error("eve tool loop produced no model steps");
+  }
+
+  return {
+    text: finalText,
+    steps: aggregatedSteps,
+    usage: lastUsage,
+  };
+}

package/templates/mcp-radar/agent/instrumentation.ts

@@ -11,7 +11,7 @@ const serviceName =
 
 export function register(): void {
   registerOTel({ serviceName });
-  registerTelemetry(new OpenTelemetry());
+  registerTelemetry(new OpenTelemetry({ runtimeContext: true }));
 }
 
 register();

package/templates/mcp-radar/lib/run-radar.ts

@@ -11,6 +11,8 @@ export const MCP_RADAR_INTENT =
 export interface RadarRunOptions {
   force?: boolean;
   reset?: boolean;
+  /** Eve Agent Runs `eve.channel.kind` (default `schedule`). */
+  channelKind?: string;
 }
 
 export interface RadarRunResult {
@@ -54,7 +56,10 @@ export async function runRadar(
   try {
     resetRunAudit();
     const agent = await ctx.getAgent();
-    const turn = await agent.generate(buildRadarGoal(options), { resetConversation: false });
+    const turn = await agent.generate(buildRadarGoal(options), {
+      resetConversation: false,
+      channelKind: options.channelKind ?? "schedule",
+    });
     void drainRunAudit();
 
     return {

package/templates/scaffold/agent/instrumentation.ts

@@ -1,10 +1,17 @@
-import { registerOTel } from "@vercel/otel";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { OpenTelemetry } from "@ai-sdk/otel";
+import { registerOTel } from "@vercel/otel";
 import { registerTelemetry } from "ai";
 
+const agentRoot = path.dirname(fileURLToPath(import.meta.url));
+const serviceName =
+  process.env.PLASM_AGENT_NAME?.trim() || path.basename(path.dirname(agentRoot));
+
 export function register(): void {
-  registerOTel({ serviceName: "plasm-agent" });
-  registerTelemetry(new OpenTelemetry());
+  registerOTel({ serviceName });
+  registerTelemetry(new OpenTelemetry({ runtimeContext: true }));
 }
 
 register();