@dexto/core 1.6.26 → 1.7.0

package/dist/systemPrompt/schemas.d.ts

@@ -1,259 +1,81 @@
 import { z } from 'zod';
-export declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-} & {
     type: z.ZodLiteral<"static">;
     content: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    type: "static";
-    enabled: boolean;
-    content: string;
-    id: string;
-    priority: number;
-}, {
-    type: "static";
-    content: string;
-    id: string;
-    priority: number;
-    enabled?: boolean | undefined;
-}>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-} & {
     type: z.ZodLiteral<"dynamic">;
-    source: z.ZodEnum<["date", "env", "resources"]>;
-}, "strict", z.ZodTypeAny, {
-    type: "dynamic";
-    enabled: boolean;
-    id: string;
-    priority: number;
-    source: "date" | "env" | "resources";
-}, {
-    type: "dynamic";
-    id: string;
-    priority: number;
-    source: "date" | "env" | "resources";
-    enabled?: boolean | undefined;
-}>, z.ZodObject<{
+    source: z.ZodEnum<{
+        date: "date";
+        env: "env";
+        resources: "resources";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-} & {
     type: z.ZodLiteral<"file">;
-    files: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
-    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    options: z.ZodPrefault<z.ZodOptional<z.ZodObject<{
         includeFilenames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         separator: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<["skip", "error"]>>>;
+        errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            skip: "skip";
+        }>>>;
         maxFileSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         includeMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strict", z.ZodTypeAny, {
-        includeFilenames: boolean;
-        separator: string;
-        errorHandling: "error" | "skip";
-        maxFileSize: number;
-        includeMetadata: boolean;
-    }, {
-        includeFilenames?: boolean | undefined;
-        separator?: string | undefined;
-        errorHandling?: "error" | "skip" | undefined;
-        maxFileSize?: number | undefined;
-        includeMetadata?: boolean | undefined;
-    }>>>;
-}, "strict", z.ZodTypeAny, {
-    type: "file";
-    options: {
-        includeFilenames: boolean;
-        separator: string;
-        errorHandling: "error" | "skip";
-        maxFileSize: number;
-        includeMetadata: boolean;
-    };
-    enabled: boolean;
-    id: string;
-    priority: number;
-    files: string[];
-}, {
-    type: "file";
-    id: string;
-    priority: number;
-    files: string[];
-    options?: {
-        includeFilenames?: boolean | undefined;
-        separator?: string | undefined;
-        errorHandling?: "error" | "skip" | undefined;
-        maxFileSize?: number | undefined;
-        includeMetadata?: boolean | undefined;
-    } | undefined;
-    enabled?: boolean | undefined;
-}>]>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>], "type">;
 export type ContributorConfig = z.input<typeof ContributorConfigSchema>;
 export type ValidatedContributorConfig = z.output<typeof ContributorConfigSchema>;
 export declare const SessionPromptContributorSchema: z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     content: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    content: string;
-    id: string;
-    priority: number;
-}, {
-    content: string;
-    id: string;
-    priority: number;
-}>;
+}, z.core.$strict>;
 export type SessionPromptContributor = z.output<typeof SessionPromptContributorSchema>;
 export declare const SystemPromptContributorsSchema: z.ZodObject<{
-    contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"static">;
         content: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        type: "static";
-        enabled: boolean;
-        content: string;
-        id: string;
-        priority: number;
-    }, {
-        type: "static";
-        content: string;
-        id: string;
-        priority: number;
-        enabled?: boolean | undefined;
-    }>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"dynamic">;
-        source: z.ZodEnum<["date", "env", "resources"]>;
-    }, "strict", z.ZodTypeAny, {
-        type: "dynamic";
-        enabled: boolean;
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-    }, {
-        type: "dynamic";
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-        enabled?: boolean | undefined;
-    }>, z.ZodObject<{
+        source: z.ZodEnum<{
+            date: "date";
+            env: "env";
+            resources: "resources";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"file">;
-        files: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
-        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        options: z.ZodPrefault<z.ZodOptional<z.ZodObject<{
             includeFilenames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             separator: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<["skip", "error"]>>>;
+            errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                skip: "skip";
+            }>>>;
             maxFileSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             includeMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, "strict", z.ZodTypeAny, {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        }, {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        }>>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "file";
-        options: {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        };
-        enabled: boolean;
-        id: string;
-        priority: number;
-        files: string[];
-    }, {
-        type: "file";
-        id: string;
-        priority: number;
-        files: string[];
-        options?: {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        } | undefined;
-        enabled?: boolean | undefined;
-    }>]>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    contributors: ({
-        type: "static";
-        enabled: boolean;
-        content: string;
-        id: string;
-        priority: number;
-    } | {
-        type: "dynamic";
-        enabled: boolean;
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-    } | {
-        type: "file";
-        options: {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        };
-        enabled: boolean;
-        id: string;
-        priority: number;
-        files: string[];
-    })[];
-}, {
-    contributors?: ({
-        type: "static";
-        content: string;
-        id: string;
-        priority: number;
-        enabled?: boolean | undefined;
-    } | {
-        type: "dynamic";
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-        enabled?: boolean | undefined;
-    } | {
-        type: "file";
-        id: string;
-        priority: number;
-        files: string[];
-        options?: {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        } | undefined;
-        enabled?: boolean | undefined;
-    })[] | undefined;
-}>;
-export declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$strict>;
+export declare const SystemPromptConfigSchema: z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
     contributors: {
         id: string;
         type: "static";
@@ -261,153 +83,41 @@ export declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEff
         priority: number;
         enabled: boolean;
     }[];
-}, string>, z.ZodObject<{
-    contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+}, string>>, z.ZodObject<{
+    contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"static">;
         content: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        type: "static";
-        enabled: boolean;
-        content: string;
-        id: string;
-        priority: number;
-    }, {
-        type: "static";
-        content: string;
-        id: string;
-        priority: number;
-        enabled?: boolean | undefined;
-    }>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"dynamic">;
-        source: z.ZodEnum<["date", "env", "resources"]>;
-    }, "strict", z.ZodTypeAny, {
-        type: "dynamic";
-        enabled: boolean;
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-    }, {
-        type: "dynamic";
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-        enabled?: boolean | undefined;
-    }>, z.ZodObject<{
+        source: z.ZodEnum<{
+            date: "date";
+            env: "env";
+            resources: "resources";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    } & {
         type: z.ZodLiteral<"file">;
-        files: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
-        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        options: z.ZodPrefault<z.ZodOptional<z.ZodObject<{
             includeFilenames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             separator: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<["skip", "error"]>>>;
+            errorHandling: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                skip: "skip";
+            }>>>;
             maxFileSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             includeMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, "strict", z.ZodTypeAny, {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        }, {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        }>>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "file";
-        options: {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        };
-        enabled: boolean;
-        id: string;
-        priority: number;
-        files: string[];
-    }, {
-        type: "file";
-        id: string;
-        priority: number;
-        files: string[];
-        options?: {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        } | undefined;
-        enabled?: boolean | undefined;
-    }>]>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    contributors: ({
-        type: "static";
-        enabled: boolean;
-        content: string;
-        id: string;
-        priority: number;
-    } | {
-        type: "dynamic";
-        enabled: boolean;
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-    } | {
-        type: "file";
-        options: {
-            includeFilenames: boolean;
-            separator: string;
-            errorHandling: "error" | "skip";
-            maxFileSize: number;
-            includeMetadata: boolean;
-        };
-        enabled: boolean;
-        id: string;
-        priority: number;
-        files: string[];
-    })[];
-}, {
-    contributors?: ({
-        type: "static";
-        content: string;
-        id: string;
-        priority: number;
-        enabled?: boolean | undefined;
-    } | {
-        type: "dynamic";
-        id: string;
-        priority: number;
-        source: "date" | "env" | "resources";
-        enabled?: boolean | undefined;
-    } | {
-        type: "file";
-        id: string;
-        priority: number;
-        files: string[];
-        options?: {
-            includeFilenames?: boolean | undefined;
-            separator?: string | undefined;
-            errorHandling?: "error" | "skip" | undefined;
-            maxFileSize?: number | undefined;
-            includeMetadata?: boolean | undefined;
-        } | undefined;
-        enabled?: boolean | undefined;
-    })[] | undefined;
-}>]>, "ValidatedSystemPromptConfig">;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$strict>]>, "ValidatedSystemPromptConfig", "out">;
 export type SystemPromptConfig = z.input<typeof SystemPromptConfigSchema>;
 export type ValidatedSystemPromptConfig = z.output<typeof SystemPromptConfigSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/systemPrompt/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0FxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkB/B,CAAC;AAGN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAElF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;EAY9B,CAAC;AAEd,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEvF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B9B,CAAC;AAGd,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAUM,CAAC;AAG5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0FxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAU/B,CAAC;AAGN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAElF,eAAO,MAAM,8BAA8B;;;;kBAY9B,CAAC;AAEd,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEvF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8B9B,CAAC;AAGd,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DAUM,CAAC;AAG5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/systemPrompt/schemas.js

@@ -39,22 +39,14 @@ const FileContributorSchema = BaseContributorSchema.extend({
     includeMetadata: z.boolean().optional().default(false).describe(
       "Whether to include file metadata (size, modification time) in the context"
     )
-  }).strict().optional().default({})
+  }).strict().optional().prefault({})
 }).strict();
 const ContributorConfigSchema = z.discriminatedUnion(
   "type",
   // The field to discriminate on
   [StaticContributorSchema, DynamicContributorSchema, FileContributorSchema],
   {
-    // Optional: Custom error message for invalid discriminator
-    errorMap: (issue, ctx) => {
-      if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
-        return {
-          message: `Invalid contributor type. Expected 'static', 'dynamic', or 'file'. Note: memory contributors are now configured via the top-level 'memories' config.`
-        };
-      }
-      return { message: ctx.defaultError };
-    }
+    error: `Invalid contributor type. Expected 'static', 'dynamic', or 'file'. Note: memory contributors are now configured via the top-level 'memories' config.`
   }
 ).describe(
   "Configuration for a system prompt contributor. Type 'static' requires 'content', type 'dynamic' requires 'source', type 'file' requires 'files'."

package/dist/telemetry/decorators.cjs

@@ -25,6 +25,7 @@ module.exports = __toCommonJS(decorators_exports);
 var import_api = require("@opentelemetry/api");
 var import_utils = require("./utils.js");
 var import_safe_stringify = require("../utils/safe-stringify.js");
+var import_runtime = require("../runtime/index.js");
 function withSpan(options) {
   return function(_target, propertyKey, descriptor) {
     if (!descriptor || typeof descriptor === "number") return;
@@ -53,7 +54,15 @@ function withSpan(options) {
       args.forEach((arg, index) => {
         span.setAttribute(`${spanName}.argument.${index}`, (0, import_safe_stringify.safeStringify)(arg, 8192));
       });
-      const { requestId, componentName, runId, threadId, resourceId, sessionId } = (0, import_utils.getBaggageValues)(ctx);
+      const {
+        requestId,
+        componentName,
+        runId,
+        threadId,
+        resourceId,
+        sessionId,
+        hostRuntime
+      } = (0, import_utils.getBaggageValues)(ctx);
       if (sessionId) {
         span.setAttribute("sessionId", sessionId);
         span.setAttribute("baggage.sessionId", sessionId);
@@ -74,65 +83,73 @@ function withSpan(options) {
         span.setAttribute("runId", String(runId));
         span.setAttribute("baggage.runId", String(runId));
       }
+      for (const [key, value] of Object.entries((0, import_runtime.getHostRuntimeAttributes)(hostRuntime))) {
+        span.setAttribute(key, value);
+      }
+      const inferredComponentName = options?.componentName;
+      const effectiveHostRuntime = hostRuntime;
+      const effectiveRunId = effectiveHostRuntime?.ids?.runId ?? runId;
       if (componentName) {
         span.setAttribute("componentName", componentName);
         span.setAttribute("baggage.componentName", componentName);
-      } else if (this && typeof this === "object") {
-        const contextObj = this;
-        const inferredName = contextObj.name ?? contextObj.constructor?.name;
-        if (inferredName) {
-          span.setAttribute("componentName", inferredName);
-        }
-        if (contextObj.runId) {
-          span.setAttribute("runId", contextObj.runId);
-          span.setAttribute("baggage.runId", contextObj.runId);
-        }
-        const existingBaggage = import_api.propagation.getBaggage(ctx);
-        const baggageEntries = {};
-        if (existingBaggage) {
-          existingBaggage.getAllEntries().forEach(([key, entry]) => {
-            baggageEntries[key] = entry;
-          });
-        }
-        if (sessionId !== void 0) {
-          baggageEntries.sessionId = {
-            ...baggageEntries.sessionId,
-            value: String(sessionId)
-          };
-        }
-        if (requestId !== void 0) {
-          baggageEntries["http.request_id"] = {
-            ...baggageEntries["http.request_id"],
-            value: String(requestId)
-          };
-        }
-        if (threadId !== void 0) {
-          baggageEntries.threadId = {
-            ...baggageEntries.threadId,
-            value: String(threadId)
-          };
-        }
-        if (resourceId !== void 0) {
-          baggageEntries.resourceId = {
-            ...baggageEntries.resourceId,
-            value: String(resourceId)
-          };
-        }
-        if (inferredName !== void 0) {
-          baggageEntries.componentName = {
-            ...baggageEntries.componentName,
-            value: String(inferredName)
-          };
-        }
-        if (contextObj.runId !== void 0) {
-          baggageEntries.runId = {
-            ...baggageEntries.runId,
-            value: String(contextObj.runId)
-          };
-        }
-        if (Object.keys(baggageEntries).length > 0) {
-          ctx = import_api.propagation.setBaggage(ctx, import_api.propagation.createBaggage(baggageEntries));
-        }
+      } else if (inferredComponentName) {
+        span.setAttribute("componentName", inferredComponentName);
+      }
+      if (effectiveRunId !== void 0) {
+        span.setAttribute("runId", String(effectiveRunId));
+        span.setAttribute("baggage.runId", String(effectiveRunId));
+      }
+      for (const [key, value] of Object.entries(
+        (0, import_runtime.getHostRuntimeAttributes)(effectiveHostRuntime)
+      )) {
+        span.setAttribute(key, value);
+      }
+      const existingBaggage = import_api.propagation.getBaggage(ctx);
+      const baggageEntries = {};
+      if (existingBaggage) {
+        existingBaggage.getAllEntries().forEach(([key, entry]) => {
+          baggageEntries[key] = entry;
+        });
+      }
+      if (sessionId !== void 0) {
+        baggageEntries.sessionId = {
+          ...baggageEntries.sessionId,
+          value: String(sessionId)
+        };
+      }
+      if (requestId !== void 0) {
+        baggageEntries["http.request_id"] = {
+          ...baggageEntries["http.request_id"],
+          value: String(requestId)
+        };
+      }
+      if (threadId !== void 0) {
+        baggageEntries.threadId = {
+          ...baggageEntries.threadId,
+          value: String(threadId)
+        };
+      }
+      if (resourceId !== void 0) {
+        baggageEntries.resourceId = {
+          ...baggageEntries.resourceId,
+          value: String(resourceId)
+        };
+      }
+      if (componentName === void 0 && inferredComponentName !== void 0) {
+        baggageEntries.componentName = {
+          ...baggageEntries.componentName,
+          value: String(inferredComponentName)
+        };
+      }
+      if (effectiveRunId !== void 0) {
+        baggageEntries.runId = {
+          ...baggageEntries.runId,
+          value: String(effectiveRunId)
+        };
+      }
+      Object.assign(baggageEntries, (0, import_runtime.getHostRuntimeBaggageEntries)(effectiveHostRuntime));
+      if (Object.keys(baggageEntries).length > 0) {
+        ctx = import_api.propagation.setBaggage(ctx, import_api.propagation.createBaggage(baggageEntries));
       }
       let result;
       try {
@@ -197,6 +214,7 @@ function InstrumentClass(options) {
             spanName: options?.prefix ? `${options.prefix}.${method}` : method,
             skipIfNoTelemetry: true,
             spanKind: options?.spanKind || import_api.SpanKind.INTERNAL,
+            componentName: options?.componentName ?? target.name,
             ...options?.tracerName !== void 0 && {
               tracerName: options.tracerName
             }

package/dist/telemetry/decorators.d.ts

@@ -1,12 +1,14 @@
 import { SpanKind } from '@opentelemetry/api';
 export declare function withSpan(options: {
     spanName?: string;
+    componentName?: string;
     skipIfNoTelemetry?: boolean;
     spanKind?: SpanKind;
     tracerName?: string;
 }): any;
 export declare function InstrumentClass(options?: {
     prefix?: string;
+    componentName?: string;
     spanKind?: SpanKind;
     excludeMethods?: string[];
     methodFilter?: (methodName: string) => boolean;