@mastra/core 0.10.13 → 0.10.14

package/dist/storage/index.js

@@ -0,0 +1,303 @@
+import { MastraStorage } from '../chunk-FL5SZ2XU.js';
+export { MastraStorage } from '../chunk-FL5SZ2XU.js';
+import { MessageList } from '../chunk-4UBOJFSL.js';
+export { TABLE_EVALS, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEMAS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT } from '../chunk-TC2SCOTE.js';
+
+// src/storage/mock.ts
+var MockStore = class extends MastraStorage {
+  data = {
+    mastra_workflow_snapshot: {},
+    mastra_evals: {},
+    mastra_messages: {},
+    mastra_threads: {},
+    mastra_traces: {},
+    mastra_resources: {}
+  };
+  constructor() {
+    super({ name: "MockStore" });
+    this.hasInitialized = Promise.resolve(true);
+  }
+  async createTable(_) {
+  }
+  async alterTable({
+    tableName
+  }) {
+    this.logger.debug(`MockStore: alterTable called for ${tableName}`);
+  }
+  async clearTable({ tableName }) {
+    this.logger.debug(`MockStore: clearTable called for ${tableName}`);
+    this.data[tableName] = {};
+  }
+  async insert({ tableName, record }) {
+    this.logger.debug(`MockStore: insert called for ${tableName}`, record);
+    this.data[tableName][record.run_id] = JSON.parse(JSON.stringify(record));
+  }
+  async batchInsert({ tableName, records }) {
+    this.logger.debug(`MockStore: batchInsert called for ${tableName} with ${records.length} records`);
+    for (const record of records) {
+      this.data[tableName][record.run_id] = JSON.parse(JSON.stringify(record));
+    }
+  }
+  async load({ tableName, keys }) {
+    this.logger.debug(`MockStore: load called for ${tableName} with keys`, keys);
+    const record = this.data[tableName][keys.run_id];
+    return record ? record : null;
+  }
+  async getThreadById({ threadId }) {
+    this.logger.debug(`MockStore: getThreadById called for ${threadId}`);
+    const thread = Object.values(this.data.mastra_threads).find((t) => t.id === threadId);
+    return thread ? thread : null;
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    this.logger.debug(`MockStore: getThreadsByResourceId called for ${resourceId}`);
+    const threads = Object.values(this.data.mastra_threads).filter((t) => t.resourceId === resourceId);
+    return threads;
+  }
+  async saveThread({ thread }) {
+    this.logger.debug(`MockStore: saveThread called for ${thread.id}`);
+    const key = thread.id;
+    this.data.mastra_threads[key] = thread;
+    return thread;
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    this.logger.debug(`MockStore: updateThread called for ${id}`);
+    const thread = this.data.mastra_threads[id];
+    if (thread) {
+      thread.title = title;
+      thread.metadata = { ...thread.metadata, ...metadata };
+      thread.updatedAt = /* @__PURE__ */ new Date();
+    }
+    return thread;
+  }
+  async deleteThread({ threadId }) {
+    this.logger.debug(`MockStore: deleteThread called for ${threadId}`);
+    delete this.data.mastra_threads[threadId];
+    this.data.mastra_messages = Object.fromEntries(
+      Object.entries(this.data.mastra_messages).filter(([, msg]) => msg.threadId !== threadId)
+    );
+  }
+  async getResourceById({ resourceId }) {
+    this.logger.debug(`MockStore: getResourceById called for ${resourceId}`);
+    const resource = this.data.mastra_resources[resourceId];
+    return resource ? resource : null;
+  }
+  async saveResource({ resource }) {
+    this.logger.debug(`MockStore: saveResource called for ${resource.id}`);
+    this.data.mastra_resources[resource.id] = JSON.parse(JSON.stringify(resource));
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    this.logger.debug(`MockStore: updateResource called for ${resourceId}`);
+    let resource = this.data.mastra_resources[resourceId];
+    if (!resource) {
+      resource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      resource = {
+        ...resource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : resource.workingMemory,
+        metadata: {
+          ...resource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    this.data.mastra_resources[resourceId] = resource;
+    return resource;
+  }
+  async getMessages({ threadId, selectBy }) {
+    this.logger.debug(`MockStore: getMessages called for thread ${threadId}`);
+    let messages = Object.values(this.data.mastra_messages).filter((msg) => msg.threadId === threadId);
+    if (selectBy?.last) {
+      messages = messages.slice(-selectBy.last);
+    }
+    messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return messages;
+  }
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
+    this.logger.debug(`MockStore: saveMessages called with ${messages.length} messages`);
+    for (const message of messages) {
+      const key = message.id;
+      this.data.mastra_messages[key] = message;
+    }
+    const list = new MessageList().add(messages, "memory");
+    if (format === `v2`) return list.get.all.v2();
+    return list.get.all.v1();
+  }
+  async updateMessages(args) {
+    this.logger.debug(`MockStore: updateMessages called with ${args.messages.length} messages`);
+    const messages = args.messages.map((m) => this.data.mastra_messages[m.id]);
+    return messages;
+  }
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes,
+    filters,
+    fromDate,
+    toDate
+  }) {
+    this.logger.debug(`MockStore: getTraces called`);
+    let traces = Object.values(this.data.mastra_traces);
+    if (name) traces = traces.filter((t) => t.name?.startsWith(name));
+    if (scope) traces = traces.filter((t) => t.scope === scope);
+    if (attributes) {
+      traces = traces.filter(
+        (t) => Object.entries(attributes).every(([key, value]) => t.attributes?.[key] === value)
+      );
+    }
+    if (filters) {
+      traces = traces.filter((t) => Object.entries(filters).every(([key, value]) => t[key] === value));
+    }
+    if (fromDate) traces = traces.filter((t) => new Date(t.createdAt) >= fromDate);
+    if (toDate) traces = traces.filter((t) => new Date(t.createdAt) <= toDate);
+    traces.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return traces.slice(start, end);
+  }
+  async getEvalsByAgentName(agentName, type) {
+    this.logger.debug(`MockStore: getEvalsByAgentName called for ${agentName}`);
+    let evals = Object.values(this.data.mastra_evals).filter((e) => e.agentName === agentName);
+    if (type === "test") {
+      evals = evals.filter((e) => e.testInfo && e.testInfo.testPath);
+    } else if (type === "live") {
+      evals = evals.filter((e) => !e.testInfo || !e.testInfo.testPath);
+    }
+    evals.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return evals;
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    this.logger.debug(`MockStore: getWorkflowRuns called`);
+    let runs = Object.values(this.data.mastra_workflow_snapshot || {});
+    if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
+    if (fromDate) runs = runs.filter((run) => new Date(run.createdAt) >= fromDate);
+    if (toDate) runs = runs.filter((run) => new Date(run.createdAt) <= toDate);
+    if (resourceId) runs = runs.filter((run) => run.resourceId === resourceId);
+    const total = runs.length;
+    runs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (limit !== void 0 && offset !== void 0) {
+      const start = offset;
+      const end = start + limit;
+      runs = runs.slice(start, end);
+    }
+    const parsedRuns = runs.map((run) => ({
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : { ...run.snapshot },
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name
+    }));
+    return { runs: parsedRuns, total };
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    this.logger.debug(`MockStore: getWorkflowRunById called for runId ${runId}`);
+    let run = Object.values(this.data.mastra_workflow_snapshot || {}).find((r) => r.run_id === runId);
+    if (run && workflowName && run.workflow_name !== workflowName) {
+      run = void 0;
+    }
+    if (!run) return null;
+    const parsedRun = {
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot,
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name
+    };
+    return parsedRun;
+  }
+  async getTracesPaginated({
+    name,
+    scope,
+    attributes,
+    page,
+    perPage,
+    fromDate,
+    toDate
+  }) {
+    this.logger.debug(`MockStore: getTracesPaginated called`);
+    let traces = Object.values(this.data.mastra_traces);
+    if (name) traces = traces.filter((t) => t.name?.startsWith(name));
+    if (scope) traces = traces.filter((t) => t.scope === scope);
+    if (attributes) {
+      traces = traces.filter(
+        (t) => Object.entries(attributes).every(([key, value]) => t.attributes?.[key] === value)
+      );
+    }
+    if (fromDate) traces = traces.filter((t) => new Date(t.createdAt) >= fromDate);
+    if (toDate) traces = traces.filter((t) => new Date(t.createdAt) <= toDate);
+    traces.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return {
+      traces: traces.slice(start, end),
+      total: traces.length,
+      page,
+      perPage,
+      hasMore: traces.length > end
+    };
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    this.logger.debug(`MockStore: getThreadsByResourceIdPaginated called for ${args.resourceId}`);
+    const threads = Object.values(this.data.mastra_threads).filter((t) => t.resourceId === args.resourceId);
+    return {
+      threads: threads.slice(args.page * args.perPage, (args.page + 1) * args.perPage),
+      total: threads.length,
+      page: args.page,
+      perPage: args.perPage,
+      hasMore: threads.length > (args.page + 1) * args.perPage
+    };
+  }
+  async getMessagesPaginated({
+    threadId,
+    selectBy
+  }) {
+    this.logger.debug(`MockStore: getMessagesPaginated called for thread ${threadId}`);
+    const { page = 0, perPage = 40 } = selectBy?.pagination || {};
+    let messages = Object.values(this.data.mastra_messages).filter((msg) => msg.threadId === threadId);
+    if (selectBy?.last) {
+      messages = messages.slice(-selectBy.last);
+    }
+    messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return {
+      messages: messages.slice(start, end),
+      total: messages.length,
+      page,
+      perPage,
+      hasMore: messages.length > end
+    };
+  }
+};
+
+export { MockStore };

package/dist/telemetry/index.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var chunkQQ5K5TZE_cjs = require('../chunk-QQ5K5TZE.cjs');
+
+
+
+Object.defineProperty(exports, "InstrumentClass", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.InstrumentClass; }
+});
+Object.defineProperty(exports, "OTLPStorageExporter", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.OTLPTraceExporter; }
+});
+Object.defineProperty(exports, "Telemetry", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.Telemetry; }
+});
+Object.defineProperty(exports, "getBaggageValues", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.getBaggageValues; }
+});
+Object.defineProperty(exports, "hasActiveTelemetry", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.hasActiveTelemetry; }
+});
+Object.defineProperty(exports, "withSpan", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.withSpan; }
+});

package/dist/telemetry/index.d.cts

@@ -0,0 +1,75 @@
+export { O as OtelConfig, S as SamplingStrategy, a as Telemetry, T as Trace } from '../base-B_y9sMg0.cjs';
+import { SpanKind, Context } from '@opentelemetry/api';
+import { ExportResult } from '@opentelemetry/core';
+import { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { I as IMastraLogger } from '../logger-B8XXh6ya.cjs';
+import { o as MastraStorage } from '../base-CS5eSXbL.cjs';
+import '../error/index.cjs';
+import 'stream';
+import 'ai';
+import 'zod';
+import 'json-schema';
+import '../types-Bo1uigWx.cjs';
+import 'sift';
+import '../runtime-context/index.cjs';
+import 'xstate';
+import 'node:events';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
+import '../tts/index.cjs';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.cjs';
+import 'ai/test';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import 'hono/cors';
+import 'hono-openapi';
+
+declare function withSpan(options: {
+    spanName?: string;
+    skipIfNoTelemetry?: boolean;
+    spanKind?: SpanKind;
+    tracerName?: string;
+}): any;
+declare function InstrumentClass(options?: {
+    prefix?: string;
+    spanKind?: SpanKind;
+    excludeMethods?: string[];
+    methodFilter?: (methodName: string) => boolean;
+    tracerName?: string;
+}): (target: any) => any;
+
+declare function hasActiveTelemetry(tracerName?: string): boolean;
+/**
+ * Get baggage values from context
+ * @param ctx The context to get baggage values from
+ * @returns
+ */
+declare function getBaggageValues(ctx: Context): {
+    requestId: string | undefined;
+    componentName: string | undefined;
+    runId: string | undefined;
+};
+
+declare class OTLPTraceExporter implements SpanExporter {
+    private storage;
+    private queue;
+    private serializer;
+    private logger;
+    private activeFlush;
+    constructor({ logger, storage }: {
+        logger: IMastraLogger;
+        storage: MastraStorage;
+    });
+    export(internalRepresentation: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    forceFlush(): Promise<void>;
+    __setLogger(logger: IMastraLogger): void;
+}
+
+export { InstrumentClass, OTLPTraceExporter as OTLPStorageExporter, getBaggageValues, hasActiveTelemetry, withSpan };

package/dist/telemetry/index.d.ts

@@ -0,0 +1,75 @@
+export { O as OtelConfig, S as SamplingStrategy, a as Telemetry, T as Trace } from '../base-ClrXcCRx.js';
+import { SpanKind, Context } from '@opentelemetry/api';
+import { ExportResult } from '@opentelemetry/core';
+import { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { I as IMastraLogger } from '../logger-Bpa2oLL4.js';
+import { o as MastraStorage } from '../base-DBhKcre4.js';
+import '../error/index.js';
+import 'stream';
+import 'ai';
+import 'zod';
+import 'json-schema';
+import '../types-Bo1uigWx.js';
+import 'sift';
+import '../runtime-context/index.js';
+import 'xstate';
+import 'node:events';
+import '../vector/index.js';
+import '../vector/filter/index.js';
+import '../tts/index.js';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.js';
+import 'ai/test';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import 'hono/cors';
+import 'hono-openapi';
+
+declare function withSpan(options: {
+    spanName?: string;
+    skipIfNoTelemetry?: boolean;
+    spanKind?: SpanKind;
+    tracerName?: string;
+}): any;
+declare function InstrumentClass(options?: {
+    prefix?: string;
+    spanKind?: SpanKind;
+    excludeMethods?: string[];
+    methodFilter?: (methodName: string) => boolean;
+    tracerName?: string;
+}): (target: any) => any;
+
+declare function hasActiveTelemetry(tracerName?: string): boolean;
+/**
+ * Get baggage values from context
+ * @param ctx The context to get baggage values from
+ * @returns
+ */
+declare function getBaggageValues(ctx: Context): {
+    requestId: string | undefined;
+    componentName: string | undefined;
+    runId: string | undefined;
+};
+
+declare class OTLPTraceExporter implements SpanExporter {
+    private storage;
+    private queue;
+    private serializer;
+    private logger;
+    private activeFlush;
+    constructor({ logger, storage }: {
+        logger: IMastraLogger;
+        storage: MastraStorage;
+    });
+    export(internalRepresentation: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    forceFlush(): Promise<void>;
+    __setLogger(logger: IMastraLogger): void;
+}
+
+export { InstrumentClass, OTLPTraceExporter as OTLPStorageExporter, getBaggageValues, hasActiveTelemetry, withSpan };

package/dist/telemetry/index.js

@@ -0,0 +1 @@
+export { InstrumentClass, OTLPTraceExporter as OTLPStorageExporter, Telemetry, getBaggageValues, hasActiveTelemetry, withSpan } from '../chunk-TC2SCOTE.js';

package/dist/telemetry/otel-vendor.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+var sdkNode = require('@opentelemetry/sdk-node');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var resources = require('@opentelemetry/resources');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var exporterTraceOtlpGrpc = require('@opentelemetry/exporter-trace-otlp-grpc');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var core = require('@opentelemetry/core');
+
+var CompositeExporter = class {
+  exporters;
+  constructor(exporters) {
+    this.exporters = exporters;
+  }
+  export(spans, resultCallback) {
+    const telemetryTraceIds = new Set(
+      spans.filter((span) => {
+        const attrs = span.attributes || {};
+        const httpTarget = attrs["http.target"];
+        return httpTarget === "/api/telemetry";
+      }).map((span) => span.spanContext().traceId)
+    );
+    const filteredSpans = spans.filter((span) => !telemetryTraceIds.has(span.spanContext().traceId));
+    if (filteredSpans.length === 0) {
+      resultCallback({ code: core.ExportResultCode.SUCCESS });
+      return;
+    }
+    void Promise.all(
+      this.exporters.map(
+        (exporter) => new Promise((resolve) => {
+          if (exporter.export) {
+            exporter.export(filteredSpans, resolve);
+          } else {
+            resolve({ code: core.ExportResultCode.FAILED });
+          }
+        })
+      )
+    ).then((results) => {
+      const hasError = results.some((r) => r.code === core.ExportResultCode.FAILED);
+      resultCallback({
+        code: hasError ? core.ExportResultCode.FAILED : core.ExportResultCode.SUCCESS
+      });
+    }).catch((error) => {
+      console.error("[CompositeExporter] Export error:", error);
+      resultCallback({ code: core.ExportResultCode.FAILED, error });
+    });
+  }
+  shutdown() {
+    return Promise.all(this.exporters.map((e) => e.shutdown?.() ?? Promise.resolve())).then(() => void 0);
+  }
+  forceFlush() {
+    return Promise.all(this.exporters.map((e) => e.forceFlush?.() ?? Promise.resolve())).then(() => void 0);
+  }
+};
+
+Object.defineProperty(exports, "NodeSDK", {
+  enumerable: true,
+  get: function () { return sdkNode.NodeSDK; }
+});
+Object.defineProperty(exports, "ConsoleSpanExporter", {
+  enumerable: true,
+  get: function () { return sdkTraceNode.ConsoleSpanExporter; }
+});
+Object.defineProperty(exports, "getNodeAutoInstrumentations", {
+  enumerable: true,
+  get: function () { return autoInstrumentationsNode.getNodeAutoInstrumentations; }
+});
+Object.defineProperty(exports, "ATTR_SERVICE_NAME", {
+  enumerable: true,
+  get: function () { return semanticConventions.ATTR_SERVICE_NAME; }
+});
+Object.defineProperty(exports, "resourceFromAttributes", {
+  enumerable: true,
+  get: function () { return resources.resourceFromAttributes; }
+});
+Object.defineProperty(exports, "OTLPHttpExporter", {
+  enumerable: true,
+  get: function () { return exporterTraceOtlpHttp.OTLPTraceExporter; }
+});
+Object.defineProperty(exports, "OTLPGrpcExporter", {
+  enumerable: true,
+  get: function () { return exporterTraceOtlpGrpc.OTLPTraceExporter; }
+});
+Object.defineProperty(exports, "AlwaysOffSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.AlwaysOffSampler; }
+});
+Object.defineProperty(exports, "AlwaysOnSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.AlwaysOnSampler; }
+});
+Object.defineProperty(exports, "ParentBasedSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.ParentBasedSampler; }
+});
+Object.defineProperty(exports, "TraceIdRatioBasedSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.TraceIdRatioBasedSampler; }
+});
+exports.CompositeExporter = CompositeExporter;

package/dist/telemetry/otel-vendor.d.cts

@@ -0,0 +1,20 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { resourceFromAttributes } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { OTLPTraceExporter as OTLPGrpcExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, Sampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';
+import { ExportResult } from '@opentelemetry/core';
+
+declare class CompositeExporter implements SpanExporter {
+    private exporters;
+    constructor(exporters: SpanExporter[]);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+
+export { CompositeExporter };

package/dist/telemetry/otel-vendor.d.ts

@@ -0,0 +1,20 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { resourceFromAttributes } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { OTLPTraceExporter as OTLPGrpcExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, Sampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';
+import { ExportResult } from '@opentelemetry/core';
+
+declare class CompositeExporter implements SpanExporter {
+    private exporters;
+    constructor(exporters: SpanExporter[]);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+
+export { CompositeExporter };

package/dist/telemetry/otel-vendor.js

@@ -0,0 +1,57 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { resourceFromAttributes } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { OTLPTraceExporter as OTLPGrpcExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';
+import { ExportResultCode } from '@opentelemetry/core';
+
+var CompositeExporter = class {
+  exporters;
+  constructor(exporters) {
+    this.exporters = exporters;
+  }
+  export(spans, resultCallback) {
+    const telemetryTraceIds = new Set(
+      spans.filter((span) => {
+        const attrs = span.attributes || {};
+        const httpTarget = attrs["http.target"];
+        return httpTarget === "/api/telemetry";
+      }).map((span) => span.spanContext().traceId)
+    );
+    const filteredSpans = spans.filter((span) => !telemetryTraceIds.has(span.spanContext().traceId));
+    if (filteredSpans.length === 0) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+    void Promise.all(
+      this.exporters.map(
+        (exporter) => new Promise((resolve) => {
+          if (exporter.export) {
+            exporter.export(filteredSpans, resolve);
+          } else {
+            resolve({ code: ExportResultCode.FAILED });
+          }
+        })
+      )
+    ).then((results) => {
+      const hasError = results.some((r) => r.code === ExportResultCode.FAILED);
+      resultCallback({
+        code: hasError ? ExportResultCode.FAILED : ExportResultCode.SUCCESS
+      });
+    }).catch((error) => {
+      console.error("[CompositeExporter] Export error:", error);
+      resultCallback({ code: ExportResultCode.FAILED, error });
+    });
+  }
+  shutdown() {
+    return Promise.all(this.exporters.map((e) => e.shutdown?.() ?? Promise.resolve())).then(() => void 0);
+  }
+  forceFlush() {
+    return Promise.all(this.exporters.map((e) => e.forceFlush?.() ?? Promise.resolve())).then(() => void 0);
+  }
+};
+
+export { CompositeExporter };