@elizaos/core 1.5.1 → 1.5.2

package/src/sentry/instrument.browser.ts

@@ -0,0 +1,65 @@
+import { getEnv, getBooleanEnv, getNumberEnv } from '../utils/environment';
+
+type SentryBrowserModule = {
+  init: (options: Record<string, any>) => void;
+  captureException: (error: unknown) => void;
+  flush?: (timeout?: number) => Promise<boolean>;
+  onLoad?: (cb: () => void) => void;
+};
+
+let initialized = false;
+let sentryClient: SentryBrowserModule | null = null;
+
+async function ensureSentryInitialized(): Promise<SentryBrowserModule | null> {
+  if (getEnv('SENTRY_LOGGING') === 'false') return null;
+
+  const dsn =
+    getEnv('SENTRY_DSN') ||
+    'https://c20e2d51b66c14a783b0689d536f7e5c@o4509349865259008.ingest.us.sentry.io/4509352524120064';
+
+  if (initialized && sentryClient) return sentryClient;
+
+  try {
+    const mod = (await import('@sentry/browser')) as unknown as SentryBrowserModule;
+
+    const init = () =>
+      mod.init({
+        dsn,
+        environment: getEnv('SENTRY_ENVIRONMENT') || getEnv('NODE_ENV', 'development'),
+        tracesSampleRate: (getNumberEnv('SENTRY_TRACES_SAMPLE_RATE', 1.0) as number) ?? 1.0,
+        sendDefaultPii: getBooleanEnv('SENTRY_SEND_DEFAULT_PII', false),
+      });
+
+    if (typeof mod.onLoad === 'function') {
+      mod.onLoad(init);
+    } else {
+      init();
+    }
+
+    initialized = true;
+    sentryClient = mod;
+    return sentryClient;
+  } catch {
+    initialized = true;
+    sentryClient = null;
+    return null;
+  }
+}
+
+export const Sentry = {
+  async captureException(error: unknown) {
+    const client = await ensureSentryInitialized();
+    try {
+      client?.captureException?.(error);
+    } catch {}
+  },
+  async flush(timeout?: number): Promise<boolean> {
+    const client = await ensureSentryInitialized();
+    try {
+      if (client?.flush) return await client.flush(timeout);
+    } catch {}
+    return true;
+  },
+};
+
+export type { SentryBrowserModule };

package/src/sentry/instrument.node.ts

@@ -0,0 +1,57 @@
+import { getEnv, getBooleanEnv, getNumberEnv } from '../utils/environment';
+
+type SentryNodeModule = {
+  init: (options: Record<string, any>) => void;
+  captureException: (error: unknown) => void;
+  flush?: (timeout?: number) => Promise<boolean>;
+};
+
+let initialized = false;
+let sentryClient: SentryNodeModule | null = null;
+
+async function ensureSentryInitialized(): Promise<SentryNodeModule | null> {
+  if (getEnv('SENTRY_LOGGING') === 'false') return null;
+
+  const dsn =
+    getEnv('SENTRY_DSN') ||
+    'https://c20e2d51b66c14a783b0689d536f7e5c@o4509349865259008.ingest.us.sentry.io/4509352524120064';
+
+  if (initialized && sentryClient) return sentryClient;
+
+  try {
+    const mod = (await import('@sentry/node')) as unknown as SentryNodeModule;
+
+    mod.init({
+      dsn,
+      environment: getEnv('SENTRY_ENVIRONMENT') || getEnv('NODE_ENV', 'development'),
+      tracesSampleRate: (getNumberEnv('SENTRY_TRACES_SAMPLE_RATE', 1.0) as number) ?? 1.0,
+      sendDefaultPii: getBooleanEnv('SENTRY_SEND_DEFAULT_PII', false),
+    });
+
+    initialized = true;
+    sentryClient = mod;
+    return sentryClient;
+  } catch {
+    initialized = true;
+    sentryClient = null;
+    return null;
+  }
+}
+
+export const Sentry = {
+  async captureException(error: unknown) {
+    const client = await ensureSentryInitialized();
+    try {
+      client?.captureException?.(error);
+    } catch {}
+  },
+  async flush(timeout?: number): Promise<boolean> {
+    const client = await ensureSentryInitialized();
+    try {
+      if (client?.flush) return await client.flush(timeout);
+    } catch {}
+    return true;
+  },
+};
+
+export type { SentryNodeModule };

package/src/sentry/instrument.ts

@@ -0,0 +1,82 @@
+import { getEnv, getBooleanEnv, getNumberEnv, detectEnvironment } from '../utils/environment';
+
+type SentryModule = {
+  init: (options: Record<string, any>) => void;
+  captureException: (error: unknown) => void;
+  flush?: (timeout?: number) => Promise<boolean>;
+  onLoad?: (cb: () => void) => void; // only present in browser sdk types
+};
+
+let initialized = false;
+let sentryClient: SentryModule | null = null;
+
+async function ensureSentryInitialized(): Promise<SentryModule | null> {
+  if (getEnv('SENTRY_LOGGING') === 'false') return null;
+
+  const dsn =
+    getEnv('SENTRY_DSN') ||
+    'https://c20e2d51b66c14a783b0689d536f7e5c@o4509349865259008.ingest.us.sentry.io/4509352524120064';
+
+  if (initialized && sentryClient) return sentryClient;
+
+  const isBrowser = detectEnvironment() === 'browser';
+
+  try {
+    if (isBrowser) {
+      const mod = (await import('@sentry/browser')) as unknown as SentryModule;
+
+      const init = () =>
+        mod.init({
+          dsn,
+          environment: getEnv('SENTRY_ENVIRONMENT') || getEnv('NODE_ENV', 'development'),
+          tracesSampleRate: (getNumberEnv('SENTRY_TRACES_SAMPLE_RATE', 1.0) as number) ?? 1.0,
+          sendDefaultPii: getBooleanEnv('SENTRY_SEND_DEFAULT_PII', false),
+        });
+
+      if (typeof mod.onLoad === 'function') {
+        mod.onLoad(init);
+      } else {
+        init();
+      }
+
+      initialized = true;
+      sentryClient = mod;
+      return sentryClient;
+    } else {
+      const mod = (await import('@sentry/node')) as unknown as SentryModule;
+
+      mod.init({
+        dsn,
+        environment: getEnv('SENTRY_ENVIRONMENT') || getEnv('NODE_ENV', 'development'),
+        tracesSampleRate: (getNumberEnv('SENTRY_TRACES_SAMPLE_RATE', 1.0) as number) ?? 1.0,
+        sendDefaultPii: getBooleanEnv('SENTRY_SEND_DEFAULT_PII', false),
+      });
+
+      initialized = true;
+      sentryClient = mod;
+      return sentryClient;
+    }
+  } catch {
+    initialized = true;
+    sentryClient = null;
+    return null;
+  }
+}
+
+export const Sentry = {
+  async captureException(error: unknown) {
+    const client = await ensureSentryInitialized();
+    try {
+      client?.captureException?.(error);
+    } catch {}
+  },
+  async flush(timeout?: number): Promise<boolean> {
+    const client = await ensureSentryInitialized();
+    try {
+      if (client?.flush) return await client.flush(timeout);
+    } catch {}
+    return true;
+  },
+};
+
+export type { SentryModule };

package/src/services.ts

@@ -0,0 +1,105 @@
+import { Service } from './types';
+import type { IAgentRuntime, ServiceTypeName } from './types';
+
+/**
+ * Service builder class that provides type-safe service creation
+ * with automatic type inference
+ */
+export class ServiceBuilder<TService extends Service = Service> {
+  protected serviceType: ServiceTypeName | string;
+  protected startFn!: (runtime: IAgentRuntime) => Promise<TService>;
+  protected stopFn?: () => Promise<void>;
+  protected description: string;
+
+  constructor(serviceType: ServiceTypeName | string) {
+    this.serviceType = serviceType;
+    this.description = '';
+  }
+
+  /**
+   * Set the service description
+   */
+  withDescription(description: string): this {
+    this.description = description;
+    return this;
+  }
+
+  /**
+   * Set the start function for the service
+   */
+  withStart(startFn: (runtime: IAgentRuntime) => Promise<TService>): this {
+    this.startFn = startFn;
+    return this;
+  }
+
+  /**
+   * Set the stop function for the service
+   */
+  withStop(stopFn: () => Promise<void>): this {
+    this.stopFn = stopFn;
+    return this;
+  }
+
+  /**
+   * Build the service class with all configured properties
+   */
+  build(): new (runtime?: IAgentRuntime) => TService {
+    const serviceType = this.serviceType;
+    const description = this.description;
+    const startFn = this.startFn;
+    const stopFn = this.stopFn;
+
+    // Create a dynamic class with the configured properties
+    return class extends (Service as any) {
+      static serviceType = serviceType;
+      capabilityDescription = description;
+
+      static async start(runtime: IAgentRuntime): Promise<Service> {
+        if (!startFn) {
+          throw new Error(`Start function not defined for service ${serviceType}`);
+        }
+        return startFn(runtime);
+      }
+
+      async stop(): Promise<void> {
+        if (stopFn) {
+          await stopFn();
+        }
+      }
+    } as any;
+  }
+}
+
+/**
+ * Create a type-safe service builder
+ * @param serviceType - The service type name
+ * @returns A new ServiceBuilder instance
+ */
+export function createService<TService extends Service = Service>(
+  serviceType: ServiceTypeName | string
+): ServiceBuilder<TService> {
+  return new ServiceBuilder<TService>(serviceType);
+}
+
+/**
+ * Type-safe service definition helper
+ */
+export interface ServiceDefinition<T extends Service = Service> {
+  serviceType: ServiceTypeName;
+  description: string;
+  start: (runtime: IAgentRuntime) => Promise<T>;
+  stop?: () => Promise<void>;
+}
+
+/**
+ * Define a service with type safety
+ */
+export function defineService<T extends Service = Service>(
+  definition: ServiceDefinition<T>
+): new (runtime?: IAgentRuntime) => T {
+  return createService<T>(definition.serviceType)
+    .withDescription(definition.description)
+    .withStart(definition.start)
+    .withStop(definition.stop || (() => Promise.resolve()))
+    .build();
+}