@dexto/core 1.1.10 → 1.2.0

package/dist/systemPrompt/schemas.d.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-
-declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     id: z.ZodString;
     priority: z.ZodNumber;
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -9,15 +8,15 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     content: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     type: "static";
-    content: string;
     id: string;
     priority: number;
     enabled: boolean;
+    content: string;
 }, {
     type: "static";
-    content: string;
     id: string;
     priority: number;
+    content: string;
     enabled?: boolean | undefined;
 }>, z.ZodObject<{
     id: z.ZodString;
@@ -31,12 +30,12 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
     id: string;
     priority: number;
     enabled: boolean;
-    source: "resources" | "dateTime" | "memorySummary";
+    source: "dateTime" | "memorySummary" | "resources";
 }, {
     type: "dynamic";
     id: string;
     priority: number;
-    source: "resources" | "dateTime" | "memorySummary";
+    source: "dateTime" | "memorySummary" | "resources";
     enabled?: boolean | undefined;
 }>, z.ZodObject<{
     id: z.ZodString;
@@ -90,10 +89,54 @@ declare const ContributorConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObj
         includeMetadata?: boolean | undefined;
     } | undefined;
     enabled?: boolean | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    priority: z.ZodNumber;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+} & {
+    type: z.ZodLiteral<"memory">;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strict", z.ZodTypeAny, {
+        includeTimestamps: boolean;
+        includeTags: boolean;
+        pinnedOnly: boolean;
+        limit?: number | undefined;
+    }, {
+        includeTimestamps?: boolean | undefined;
+        includeTags?: boolean | undefined;
+        limit?: number | undefined;
+        pinnedOnly?: boolean | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    options: {
+        includeTimestamps: boolean;
+        includeTags: boolean;
+        pinnedOnly: boolean;
+        limit?: number | undefined;
+    };
+    type: "memory";
+    id: string;
+    priority: number;
+    enabled: boolean;
+}, {
+    type: "memory";
+    id: string;
+    priority: number;
+    options?: {
+        includeTimestamps?: boolean | undefined;
+        includeTags?: boolean | undefined;
+        limit?: number | undefined;
+        pinnedOnly?: boolean | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
 }>]>;
-type ContributorConfig = z.input<typeof ContributorConfigSchema>;
-type ValidatedContributorConfig = z.output<typeof ContributorConfigSchema>;
-declare const SystemPromptContributorsSchema: z.ZodObject<{
+export type ContributorConfig = z.input<typeof ContributorConfigSchema>;
+export type ValidatedContributorConfig = z.output<typeof ContributorConfigSchema>;
+export declare const SystemPromptContributorsSchema: z.ZodObject<{
     contributors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         id: z.ZodString;
         priority: z.ZodNumber;
@@ -103,15 +146,15 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         content: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     }, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -125,12 +168,12 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     }, {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -184,20 +227,64 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNumber;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    } & {
+        type: z.ZodLiteral<"memory">;
+        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strict", z.ZodTypeAny, {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        }, {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        }>>>;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
+    }, {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     }>]>, "many">>;
 }, "strict", z.ZodTypeAny, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     } | {
         options: {
             includeFilenames: boolean;
@@ -211,19 +298,30 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
         priority: number;
         enabled: boolean;
         files: string[];
+    } | {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
     })[];
 }, {
     contributors?: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     } | {
         type: "file";
@@ -238,9 +336,20 @@ declare const SystemPromptContributorsSchema: z.ZodObject<{
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    } | {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     })[] | undefined;
 }>;
-declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
+export declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
     contributors: {
         id: string;
         type: "static";
@@ -258,15 +367,15 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         content: z.ZodString;
     }, "strict", z.ZodTypeAny, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     }, {
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -280,12 +389,12 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     }, {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     }>, z.ZodObject<{
         id: z.ZodString;
@@ -339,20 +448,64 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNumber;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    } & {
+        type: z.ZodLiteral<"memory">;
+        options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            includeTimestamps: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            includeTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            pinnedOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strict", z.ZodTypeAny, {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        }, {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        }>>>;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
+    }, {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     }>]>, "many">>;
 }, "strict", z.ZodTypeAny, {
     contributors: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
         enabled: boolean;
+        content: string;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
         enabled: boolean;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
     } | {
         options: {
             includeFilenames: boolean;
@@ -366,19 +519,30 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
         priority: number;
         enabled: boolean;
         files: string[];
+    } | {
+        options: {
+            includeTimestamps: boolean;
+            includeTags: boolean;
+            pinnedOnly: boolean;
+            limit?: number | undefined;
+        };
+        type: "memory";
+        id: string;
+        priority: number;
+        enabled: boolean;
     })[];
 }, {
     contributors?: ({
         type: "static";
-        content: string;
         id: string;
         priority: number;
+        content: string;
         enabled?: boolean | undefined;
     } | {
         type: "dynamic";
         id: string;
         priority: number;
-        source: "resources" | "dateTime" | "memorySummary";
+        source: "dateTime" | "memorySummary" | "resources";
         enabled?: boolean | undefined;
     } | {
         type: "file";
@@ -393,9 +557,19 @@ declare const SystemPromptConfigSchema: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.
             includeMetadata?: boolean | undefined;
         } | undefined;
         enabled?: boolean | undefined;
+    } | {
+        type: "memory";
+        id: string;
+        priority: number;
+        options?: {
+            includeTimestamps?: boolean | undefined;
+            includeTags?: boolean | undefined;
+            limit?: number | undefined;
+            pinnedOnly?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
     })[] | undefined;
 }>]>, "ValidatedSystemPromptConfig">;
-type SystemPromptConfig = z.input<typeof SystemPromptConfigSchema>;
-type ValidatedSystemPromptConfig = z.output<typeof SystemPromptConfigSchema>;
-
-export { type ContributorConfig, ContributorConfigSchema, type SystemPromptConfig, SystemPromptConfigSchema, SystemPromptContributorsSchema, type ValidatedContributorConfig, type ValidatedSystemPromptConfig };
+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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+GxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuB/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB9B,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"}

package/dist/systemPrompt/schemas.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { z } from "zod";
 import { PROMPT_GENERATOR_SOURCES } from "./registry.js";
 const BaseContributorSchema = z.object({
@@ -30,23 +31,37 @@ const FileContributorSchema = BaseContributorSchema.extend({
     )
   }).strict().optional().default({})
 }).strict();
+const MemoryContributorSchema = BaseContributorSchema.extend({
+  type: z.literal("memory"),
+  options: z.object({
+    includeTimestamps: z.boolean().optional().default(false).describe("Whether to include timestamps in memory display"),
+    includeTags: z.boolean().optional().default(true).describe("Whether to include tags in memory display"),
+    limit: z.number().int().positive().optional().describe("Maximum number of memories to include"),
+    pinnedOnly: z.boolean().optional().default(false).describe("Only include pinned memories (for hybrid approach)")
+  }).strict().optional().default({})
+}).strict();
 const ContributorConfigSchema = z.discriminatedUnion(
   "type",
   // The field to discriminate on
-  [StaticContributorSchema, DynamicContributorSchema, FileContributorSchema],
+  [
+    StaticContributorSchema,
+    DynamicContributorSchema,
+    FileContributorSchema,
+    MemoryContributorSchema
+  ],
   {
     // 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'.`
+          message: `Invalid contributor type. Expected 'static', 'dynamic', 'file', or 'memory'.`
         };
       }
       return { message: ctx.defaultError };
     }
   }
 ).describe(
-  "Configuration for a system prompt contributor. Type 'static' requires 'content', type 'dynamic' requires 'source', type 'file' requires 'files'."
+  "Configuration for a system prompt contributor. Type 'static' requires 'content', type 'dynamic' requires 'source', type 'file' requires 'files', type 'memory' loads user memories."
 );
 const SystemPromptContributorsSchema = z.object({
   contributors: z.array(ContributorConfigSchema).min(1).default([

package/dist/systemPrompt/types.d.ts

@@ -1,19 +1,10 @@
 import { MCPManager } from '../mcp/manager.js';
-import '../mcp/schemas.js';
-import 'zod';
-import '../mcp/types.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.js';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-
-interface DynamicContributorContext {
+export interface DynamicContributorContext {
     mcpManager: MCPManager;
 }
-interface SystemPromptContributor {
+export interface SystemPromptContributor {
     id: string;
     priority: number;
     getContent(context: DynamicContributorContext): Promise<string>;
 }
-
-export type { DynamicContributorContext, SystemPromptContributor };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,UAAU,CAAC;CAC1B;AAGD,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACnE"}

package/dist/telemetry/decorators.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+__export(decorators_exports, {
+  InstrumentClass: () => InstrumentClass,
+  withSpan: () => withSpan
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_api = require("@opentelemetry/api");
+var import_logger = require("../logger/index.js");
+var import_utils = require("./utils.js");
+var import_safe_stringify = require("../utils/safe-stringify.js");
+function withSpan(options) {
+  return function(_target, propertyKey, descriptor) {
+    if (!descriptor || typeof descriptor === "number") return;
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function(...args) {
+      if (options?.skipIfNoTelemetry && (!globalThis.__TELEMETRY__ || !(0, import_utils.hasActiveTelemetry)())) {
+        return originalMethod.apply(this, args);
+      }
+      const tracer = import_api.trace.getTracer(options?.tracerName ?? "dexto");
+      let spanName = methodName;
+      let spanKind;
+      if (options) {
+        spanName = options.spanName ?? methodName;
+        if (options.spanKind !== void 0) {
+          spanKind = options.spanKind;
+        }
+      }
+      const spanOptions = {};
+      if (spanKind !== void 0) {
+        spanOptions.kind = spanKind;
+      }
+      const span = tracer.startSpan(spanName, spanOptions);
+      let ctx = import_api.trace.setSpan(import_api.context.active(), span);
+      args.forEach((arg, index) => {
+        span.setAttribute(`${spanName}.argument.${index}`, (0, import_safe_stringify.safeStringify)(arg, 8192));
+      });
+      const { requestId, componentName, runId, threadId, resourceId } = (0, import_utils.getBaggageValues)(ctx);
+      if (requestId) {
+        span.setAttribute("http.request_id", requestId);
+      }
+      if (threadId) {
+        span.setAttribute("threadId", threadId);
+      }
+      if (resourceId) {
+        span.setAttribute("resourceId", resourceId);
+      }
+      if (componentName) {
+        span.setAttribute("componentName", componentName);
+        if (runId !== void 0) {
+          span.setAttribute("runId", String(runId));
+        }
+      } 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);
+        }
+        const baggageEntries = {};
+        if (inferredName !== void 0) {
+          baggageEntries.componentName = { value: String(inferredName) };
+        }
+        if (contextObj.runId !== void 0) {
+          baggageEntries.runId = { value: String(contextObj.runId) };
+        }
+        if (requestId !== void 0) {
+          baggageEntries["http.request_id"] = { value: String(requestId) };
+        }
+        if (threadId !== void 0) {
+          baggageEntries.threadId = { value: String(threadId) };
+        }
+        if (resourceId !== void 0) {
+          baggageEntries.resourceId = { value: String(resourceId) };
+        }
+        if (Object.keys(baggageEntries).length > 0) {
+          ctx = import_api.propagation.setBaggage(ctx, import_api.propagation.createBaggage(baggageEntries));
+        }
+      }
+      let result;
+      try {
+        result = import_api.context.with(ctx, () => originalMethod.apply(this, args));
+        if (result instanceof Promise) {
+          return result.then((resolvedValue) => {
+            span.setAttribute(
+              `${spanName}.result`,
+              (0, import_safe_stringify.safeStringify)(resolvedValue, 8192)
+            );
+            return resolvedValue;
+          }).catch((error) => {
+            span.recordException(error);
+            span.setStatus({
+              code: import_api.SpanStatusCode.ERROR,
+              message: error?.toString()
+            });
+            throw error;
+          }).finally(() => {
+            span.end();
+          });
+        }
+        span.setAttribute(`${spanName}.result`, (0, import_safe_stringify.safeStringify)(result, 8192));
+        return result;
+      } catch (error) {
+        import_logger.logger.error(
+          `withSpan: Error in method '${methodName}': ${error instanceof Error ? error.message : String(error)}`
+        );
+        span.setStatus({
+          code: import_api.SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        if (!(result instanceof Promise)) {
+          span.end();
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+function InstrumentClass(options) {
+  return function(target) {
+    const methods = Object.getOwnPropertyNames(target.prototype);
+    methods.forEach((method) => {
+      if (options?.excludeMethods?.includes(method) || method === "constructor") {
+        return;
+      }
+      if (options?.methodFilter && !options.methodFilter(method)) return;
+      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
+      if (descriptor && typeof descriptor.value === "function") {
+        Object.defineProperty(
+          target.prototype,
+          method,
+          withSpan({
+            spanName: options?.prefix ? `${options.prefix}.${method}` : method,
+            skipIfNoTelemetry: true,
+            spanKind: options?.spanKind || import_api.SpanKind.INTERNAL,
+            ...options?.tracerName !== void 0 && {
+              tracerName: options.tracerName
+            }
+          })(target, method, descriptor)
+        );
+      }
+    });
+    return target;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InstrumentClass,
+  withSpan
+});

package/dist/telemetry/decorators.d.ts

@@ -0,0 +1,17 @@
+import { SpanKind } from '@opentelemetry/api';
+export declare function withSpan(options: {
+    spanName?: string;
+    skipIfNoTelemetry?: boolean;
+    spanKind?: SpanKind;
+    tracerName?: string;
+}): any;
+export declare function InstrumentClass(options?: {
+    prefix?: string;
+    spanKind?: SpanKind;
+    excludeMethods?: string[];
+    methodFilter?: (methodName: string) => boolean;
+    tracerName?: string;
+}): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => T;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/telemetry/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/telemetry/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,QAAQ,EAGX,MAAM,oBAAoB,CAAC;AAM5B,wBAAgB,QAAQ,CAAC,OAAO,EAAE;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,GAAG,CA6JN;AAGD,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,IACoB,CAAC,SAAS;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;CAAE,EAAE,QAAQ,CAAC,OA4BrE"}