@swifty.js/swifty 0.0.32 → 0.0.33

package/dist/lib/providers-UJEWP7C7.js

@@ -0,0 +1,419 @@
+import {
+  version
+} from "./chunk-GTHYQZRL.js";
+
+// src/telemetry/providers.ts
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import {
+  setLangfuseTracerProvider,
+  startObservation
+} from "@langfuse/tracing";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  ConsoleMetricExporter,
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  ConsoleSpanExporter
+} from "@opentelemetry/sdk-trace-base";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+var DEFAULT_EXPORT_INTERVAL_MS = 6e4;
+var SHUTDOWN_TIMEOUT_MS = 2e3;
+function parseExporterTypes(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0 && item !== "none");
+}
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function getProtocol(signal) {
+  const signalKey = `OTEL_EXPORTER_OTLP_${signal.toUpperCase()}_PROTOCOL`;
+  const configured = process.env[signalKey]?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+  const protocol = configured || "http/protobuf";
+  if (protocol === "grpc" || protocol === "http/json" || protocol === "http/protobuf") {
+    return protocol;
+  }
+  throw new Error(`Unsupported OpenTelemetry protocol: ${protocol}`);
+}
+function parseResourceAttributes(value) {
+  const attributes = {};
+  for (const entry of value?.split(",") ?? []) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = entry.slice(0, separator).trim();
+    const rawValue = entry.slice(separator + 1).trim();
+    if (key && rawValue) {
+      try {
+        attributes[decodeURIComponent(key)] = decodeURIComponent(rawValue);
+      } catch {
+        attributes[key] = rawValue;
+      }
+    }
+  }
+  return attributes;
+}
+function createResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: "swifty",
+    [ATTR_SERVICE_VERSION]: version,
+    ...parseResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES),
+    ...process.env.OTEL_SERVICE_NAME ? { [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME } : {}
+  });
+}
+async function createTraceExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-grpc");
+      return new OTLPTraceExporter();
+    }
+    case "http/json": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
+      return new OTLPTraceExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-proto");
+      return new OTLPTraceExporter();
+    }
+  }
+}
+async function createLogExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-grpc");
+      return new OTLPLogExporter();
+    }
+    case "http/json": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-http");
+      return new OTLPLogExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-proto");
+      return new OTLPLogExporter();
+    }
+  }
+}
+async function createMetricExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-grpc");
+      return new OTLPMetricExporter();
+    }
+    case "http/json": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-http");
+      return new OTLPMetricExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-proto");
+      return new OTLPMetricExporter();
+    }
+  }
+}
+async function createTracerProvider(resource) {
+  const processors = [];
+  const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER);
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      processors.push(new BatchSpanProcessor(new ConsoleSpanExporter()));
+    } else if (exporterType === "otlp") {
+      processors.push(new BatchSpanProcessor(await createTraceExporter(getProtocol("traces"))));
+    } else {
+      throw new Error(`Unsupported trace exporter: ${exporterType}`);
+    }
+  }
+  if (process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY) {
+    processors.push(
+      new LangfuseSpanProcessor({
+        mediaUploadEnabled: false,
+        release: process.env.LANGFUSE_RELEASE ?? version
+      })
+    );
+  }
+  if (processors.length === 0) {
+    return null;
+  }
+  const provider = new BasicTracerProvider({ resource, spanProcessors: processors });
+  setLangfuseTracerProvider(provider);
+  return provider;
+}
+async function createLoggerProvider(resource) {
+  const processors = [];
+  for (const exporterType of parseExporterTypes(process.env.OTEL_LOGS_EXPORTER)) {
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleLogRecordExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createLogExporter(getProtocol("logs"));
+    } else {
+      throw new Error(`Unsupported log exporter: ${exporterType}`);
+    }
+    processors.push(new BatchLogRecordProcessor({ exporter }));
+  }
+  return processors.length > 0 ? new LoggerProvider({ resource, processors }) : null;
+}
+async function createMetricReaders() {
+  const readers = [];
+  const exportIntervalMillis = parsePositiveInteger(
+    process.env.OTEL_METRIC_EXPORT_INTERVAL,
+    DEFAULT_EXPORT_INTERVAL_MS
+  );
+  for (const exporterType of parseExporterTypes(process.env.OTEL_METRICS_EXPORTER)) {
+    if (exporterType === "prometheus") {
+      const { PrometheusExporter } = await import("@opentelemetry/exporter-prometheus");
+      readers.push(new PrometheusExporter());
+      continue;
+    }
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleMetricExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createMetricExporter(getProtocol("metrics"));
+    } else {
+      throw new Error(`Unsupported metric exporter: ${exporterType}`);
+    }
+    readers.push(new PeriodicExportingMetricReader({ exporter, exportIntervalMillis }));
+  }
+  return readers;
+}
+async function initializeSentry() {
+  if (!process.env.SENTRY_DSN) {
+    return null;
+  }
+  const sentry = await import("@sentry/node");
+  sentry.init({
+    debug: process.env.SENTRY_DEBUG?.toLowerCase() === "true",
+    dsn: process.env.SENTRY_DSN,
+    environment: process.env.SENTRY_ENVIRONMENT,
+    includeLocalVariables: false,
+    integrations: (defaultIntegrations) => defaultIntegrations.filter(
+      (integration) => integration.name !== "OnUncaughtException" && integration.name !== "OnUnhandledRejection"
+    ),
+    registerEsmLoaderHooks: false,
+    release: process.env.SENTRY_RELEASE ?? version,
+    sendDefaultPii: false,
+    skipOpenTelemetrySetup: true,
+    tracesSampleRate: 0
+  });
+  return sentry;
+}
+async function safely(operation) {
+  try {
+    return await operation();
+  } catch {
+    return null;
+  }
+}
+function withTimeout(operation) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, SHUTDOWN_TIMEOUT_MS);
+    timer.unref();
+    void operation.then(
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    );
+  });
+}
+function severityNumber(severity) {
+  switch (severity) {
+    case "error":
+      return SeverityNumber.ERROR;
+    case "info":
+      return SeverityNumber.INFO;
+    case "warn":
+      return SeverityNumber.WARN;
+  }
+}
+function createRootObservation(kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return startObservation(name, { metadata: attributes }, { asType: "agent" });
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return startObservation(name, { metadata: attributes, model }, { asType: "generation" });
+    }
+    case "tool":
+      return startObservation(name, { metadata: attributes }, { asType: "tool" });
+  }
+}
+function createChildObservation(parent, kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return parent.startObservation(name, { metadata: attributes }, { asType: "agent" });
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return parent.startObservation(
+        name,
+        { metadata: attributes, model },
+        { asType: "generation" }
+      );
+    }
+    case "tool":
+      return parent.startObservation(name, { metadata: attributes }, { asType: "tool" });
+  }
+}
+var ProviderObservation = class _ProviderObservation {
+  constructor(observation) {
+    this.observation = observation;
+  }
+  observation;
+  end() {
+    this.observation.end();
+  }
+  recordException(error) {
+    const errorType = error instanceof Error ? error.name : typeof error;
+    this.observation.otelSpan.setAttribute("error.type", errorType);
+    this.observation.otelSpan.setStatus({ code: SpanStatusCode.ERROR });
+    this.observation.updateOtelSpanAttributes({
+      level: "ERROR",
+      statusMessage: errorType
+    });
+  }
+  startChild(kind, name, attributes = {}) {
+    return new _ProviderObservation(
+      createChildObservation(this.observation, kind, name, attributes)
+    );
+  }
+  update(update) {
+    this.observation.updateOtelSpanAttributes(update);
+  }
+};
+var ProviderRuntime = class {
+  constructor(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry) {
+    this.tracerProvider = tracerProvider;
+    this.loggerProvider = loggerProvider;
+    this.meterProvider = meterProvider;
+    this.meter = meter;
+    this.logger = logger;
+    this.sentry = sentry;
+  }
+  tracerProvider;
+  loggerProvider;
+  meterProvider;
+  meter;
+  logger;
+  sentry;
+  counters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  mode = "unknown";
+  captureError(error, context) {
+    this.sentry?.captureException(error, { tags: { context, mode: this.mode } });
+    this.emitLog("swifty.error", "error", {
+      context,
+      "error.type": error instanceof Error ? error.name : typeof error
+    });
+  }
+  emitLog(name, severity, attributes = {}) {
+    this.logger?.emit({
+      attributes: { ...attributes, "swifty.mode": this.mode },
+      body: name,
+      severityNumber: severityNumber(severity),
+      severityText: severity.toUpperCase()
+    });
+  }
+  async flush() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.forceFlush());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.forceFlush());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.forceFlush());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.flush(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+  }
+  recordMetric(name, kind, value, attributes = {}) {
+    if (!this.meter) {
+      return;
+    }
+    const mergedAttributes = { ...attributes, "swifty.mode": this.mode };
+    if (kind === "counter") {
+      let counter = this.counters.get(name);
+      if (!counter) {
+        counter = this.meter.createCounter(name);
+        this.counters.set(name, counter);
+      }
+      counter.add(value, mergedAttributes);
+      return;
+    }
+    let histogram = this.histograms.get(name);
+    if (!histogram) {
+      histogram = this.meter.createHistogram(name, { unit: "ms" });
+      this.histograms.set(name, histogram);
+    }
+    histogram.record(value, mergedAttributes);
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.sentry?.setTag("swifty.mode", mode);
+  }
+  async shutdown() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.shutdown());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.shutdown());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.shutdown());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.close(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+    setLangfuseTracerProvider(null);
+  }
+  startObservation(kind, name, attributes = {}) {
+    if (!this.tracerProvider) {
+      return {
+        end: () => void 0,
+        recordException: () => void 0,
+        startChild: (childKind, childName, childAttributes) => this.startObservation(childKind, childName, childAttributes),
+        update: () => void 0
+      };
+    }
+    return new ProviderObservation(
+      createRootObservation(kind, name, { ...attributes, "swifty.mode": this.mode })
+    );
+  }
+};
+async function createTelemetryRuntime() {
+  const resource = createResource();
+  const otelEnabled = process.env.OTEL_SDK_DISABLED?.toLowerCase() !== "true";
+  const [tracerProvider, loggerProvider, metricReaders, sentry] = await Promise.all([
+    otelEnabled ? safely(() => createTracerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(() => createLoggerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(createMetricReaders) : Promise.resolve(null),
+    safely(initializeSentry)
+  ]);
+  const meterProvider = metricReaders && metricReaders.length > 0 ? new MeterProvider({ readers: metricReaders, resource }) : null;
+  const meter = meterProvider?.getMeter("@swifty.js/swifty", version) ?? null;
+  const logger = loggerProvider?.getLogger("@swifty.js/swifty", version) ?? null;
+  return new ProviderRuntime(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry);
+}
+export {
+  createTelemetryRuntime,
+  parseExporterTypes
+};

package/dist/lib/{tool-filter-IMIU7CW2.js → tool-filter-BFEINZIA.js}

@@ -7,7 +7,7 @@ import {
   TEAMMATE_DISALLOWED_TOOLS,
   cloneRegistryForFork,
   filterToolsForAgent
-} from "./chunk-4BPKIIQD.js";
+} from "./chunk-LDWFI6MR.js";
 export {
   ASYNC_AGENT_ALLOWED_TOOLS,
   CUSTOM_AGENT_DISALLOWED_TOOLS,