@memoryrelay/mcp-server 0.1.9 → 0.3.0

package/dist/chunk-P6TZEH6O.js

@@ -0,0 +1,796 @@
+// src/config.ts
+import { z } from "zod";
+var configSchema = z.object({
+  apiKey: z.string().startsWith("mem_", { message: 'API key must start with "mem_"' }).min(20, { message: "API key appears to be invalid (too short)" }),
+  apiUrl: z.string().url({ message: "API URL must be a valid URL" }).default("https://api.memoryrelay.net"),
+  agentId: z.string().optional().describe("Agent identifier - auto-detected if not provided"),
+  timeout: z.number().positive({ message: "Timeout must be positive" }).default(3e4),
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info")
+});
+var TOOL_GROUPS = {
+  core: [
+    "memory_store",
+    "memory_search",
+    "memory_list",
+    "memory_get",
+    "memory_update",
+    "memory_delete",
+    "entity_create",
+    "entity_link",
+    "entity_list",
+    "entity_graph",
+    "memory_batch_store",
+    "memory_context",
+    "agent_list",
+    "agent_create",
+    "agent_get",
+    "memory_health"
+  ],
+  sessions: ["session_start", "session_end", "session_recall", "session_list"],
+  decisions: ["decision_record", "decision_list", "decision_supersede", "decision_check"],
+  patterns: ["pattern_create", "pattern_search", "pattern_adopt", "pattern_suggest"],
+  projects: ["project_register", "project_list", "project_info"],
+  relationships: [
+    "project_add_relationship",
+    "project_dependencies",
+    "project_dependents",
+    "project_related",
+    "project_impact",
+    "project_shared_patterns"
+  ],
+  context: ["project_context", "memory_promote"]
+};
+function getEnabledTools() {
+  const raw = process.env.MEMORYRELAY_TOOLS;
+  if (!raw || raw.trim().toLowerCase() === "all") {
+    return null;
+  }
+  const groups = raw.split(",").map((g) => g.trim().toLowerCase());
+  const enabled = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    const tools = TOOL_GROUPS[group];
+    if (tools) {
+      for (const tool of tools) {
+        enabled.add(tool);
+      }
+    }
+  }
+  return enabled;
+}
+function loadConfig() {
+  try {
+    const config = configSchema.parse({
+      apiKey: process.env.MEMORYRELAY_API_KEY,
+      apiUrl: process.env.MEMORYRELAY_API_URL,
+      agentId: process.env.MEMORYRELAY_AGENT_ID,
+      timeout: process.env.MEMORYRELAY_TIMEOUT ? parseInt(process.env.MEMORYRELAY_TIMEOUT, 10) : void 0,
+      logLevel: process.env.MEMORYRELAY_LOG_LEVEL
+    });
+    return config;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const issues = error.issues.map(
+        (issue) => `  - ${issue.path.join(".")}: ${issue.message}`
+      ).join("\n");
+      throw new Error(
+        `Configuration validation failed:
+${issues}
+
+Please check your environment variables:
+  - MEMORYRELAY_API_KEY (required, starts with "mem_")
+  - MEMORYRELAY_API_URL (optional, default: https://api.memoryrelay.net)
+  - MEMORYRELAY_AGENT_ID (optional, auto-detected)
+  - MEMORYRELAY_TIMEOUT (optional, default: 30000)
+  - MEMORYRELAY_LOG_LEVEL (optional, default: info)`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
+function getAgentId(config) {
+  if (config.agentId) {
+    return config.agentId;
+  }
+  const openclawAgent = process.env.OPENCLAW_AGENT_NAME;
+  if (openclawAgent) {
+    return openclawAgent.slice(0, 32);
+  }
+  const hostname = process.env.HOSTNAME || process.env.COMPUTERNAME || "unknown";
+  const user = process.env.USER || process.env.USERNAME || "";
+  return user ? `${user}-${hostname}`.slice(0, 32) : `mcp-${hostname}`.slice(0, 32);
+}
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  minLevel;
+  constructor(level = "info") {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Mask sensitive data in log messages
+   * - API keys starting with "mem_" are masked
+   * - Internal paths are sanitized
+   */
+  sanitize(message) {
+    let sanitized = message;
+    sanitized = sanitized.replace(/mem_[a-zA-Z0-9_-]+/g, "mem_****");
+    sanitized = sanitized.replace(/\/[a-zA-Z0-9_\-./]+\.(ts|js|json)/g, "<file>");
+    sanitized = sanitized.replace(/at\s+[^\s]+\s+\([^)]+\)/g, "at <location>");
+    return sanitized;
+  }
+  /**
+   * Format log message with timestamp and level
+   */
+  format(level, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const sanitizedMessage = this.sanitize(message);
+    let output = `[${timestamp}] [${level.toUpperCase()}] ${sanitizedMessage}`;
+    if (data !== void 0) {
+      const sanitizedData = this.sanitize(JSON.stringify(data, null, 2));
+      output += `
+${sanitizedData}`;
+    }
+    return output;
+  }
+  debug(message, data) {
+    if (this.minLevel <= LOG_LEVELS.debug) {
+      console.error(this.format("debug", message, data));
+    }
+  }
+  info(message, data) {
+    if (this.minLevel <= LOG_LEVELS.info) {
+      console.error(this.format("info", message, data));
+    }
+  }
+  warn(message, data) {
+    if (this.minLevel <= LOG_LEVELS.warn) {
+      console.error(this.format("warn", message, data));
+    }
+  }
+  error(message, data) {
+    if (this.minLevel <= LOG_LEVELS.error) {
+      console.error(this.format("error", message, data));
+    }
+  }
+};
+var logger;
+function initLogger(level = "info") {
+  logger = new Logger(level);
+  return logger;
+}
+function getLogger() {
+  if (!logger) {
+    logger = new Logger();
+  }
+  return logger;
+}
+
+// src/client.ts
+var MAX_RETRIES = 3;
+var INITIAL_DELAY_MS = 1e3;
+var MAX_CONTENT_SIZE = 50 * 1024;
+async function withRetry(fn, retries = MAX_RETRIES) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.message.includes("401") || lastError.message.includes("403") || lastError.message.includes("404") || lastError.message.includes("400")) {
+        throw lastError;
+      }
+      if (attempt === retries) {
+        throw lastError;
+      }
+      const delay = INITIAL_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.random() * 0.3 * delay;
+      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+function maskApiKey(message, apiKey) {
+  if (!apiKey) return message;
+  const maskedKey = apiKey.substring(0, 8) + "***";
+  return message.replace(new RegExp(apiKey, "g"), maskedKey);
+}
+var MemoryRelayClient = class {
+  config;
+  logger = getLogger();
+  constructor(config) {
+    this.config = config;
+    this.logger.info("MemoryRelay client initialized", {
+      apiUrl: config.apiUrl,
+      agentId: config.agentId
+    });
+  }
+  /**
+   * Make authenticated HTTP request to MemoryRelay API with retry logic
+   */
+  async request(method, path, body) {
+    return withRetry(async () => {
+      const url = `${this.config.apiUrl}${path}`;
+      this.logger.debug(`API request: ${method} ${path}`);
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.apiKey}`,
+            "User-Agent": "@memoryrelay/mcp-server"
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("Retry-After");
+            const waitMs = retryAfter ? parseInt(retryAfter) * 1e3 : 5e3;
+            this.logger.warn(`Rate limited, waiting ${waitMs}ms`);
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+            throw new Error(`Rate limited: 429 - Retry after ${waitMs}ms`);
+          }
+          const errorData = await response.json().catch(() => ({}));
+          const errorMsg = `API request failed: ${response.status} ${response.statusText}` + (errorData.message ? ` - ${errorData.message}` : "");
+          throw new Error(maskApiKey(errorMsg, this.config.apiKey));
+        }
+        const data = await response.json();
+        this.logger.debug(`API response: ${method} ${path}`, { status: response.status });
+        return data;
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.config.timeout}ms`, { cause: error });
+          }
+          error.message = maskApiKey(error.message, this.config.apiKey);
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeout);
+      }
+    });
+  }
+  /**
+   * Validate content size
+   */
+  validateContentSize(content) {
+    if (content.length > MAX_CONTENT_SIZE) {
+      throw new Error(`Content exceeds maximum size of ${MAX_CONTENT_SIZE} bytes`);
+    }
+  }
+  /**
+   * Store a new memory
+   */
+  async storeMemory(content, metadata, deduplicate, dedupThreshold, project, importance, tier) {
+    this.validateContentSize(content);
+    const body = {
+      content,
+      metadata,
+      agent_id: this.config.agentId
+    };
+    if (deduplicate) {
+      body.deduplicate = true;
+    }
+    if (dedupThreshold !== void 0) {
+      body.dedup_threshold = dedupThreshold;
+    }
+    if (project) {
+      body.project = project;
+    }
+    if (importance !== void 0) {
+      body.importance = importance;
+    }
+    if (tier) {
+      body.tier = tier;
+    }
+    return this.request("POST", "/v1/memories", body);
+  }
+  /**
+   * Search memories using semantic search
+   * @param agentId - Optional agent ID override. If omitted, uses config agentId. Pass null for cross-agent search.
+   * @param includeConfidential - Include confidential memories in results
+   * @param includeArchived - Include archived memories in results
+   * @param project - Optional project slug to filter by
+   */
+  async searchMemories(query, limit = 10, threshold = 0.5, agentId, includeConfidential = false, includeArchived = false, compress = false, maxContextTokens, project, tier, minImportance) {
+    this.validateContentSize(query);
+    const effectiveAgentId = agentId === null ? void 0 : agentId ?? this.config.agentId;
+    const body = { query, limit, threshold };
+    if (effectiveAgentId) {
+      body.agent_id = effectiveAgentId;
+    }
+    if (includeConfidential) {
+      body.include_confidential = true;
+    }
+    if (includeArchived) {
+      body.include_archived = true;
+    }
+    if (compress) {
+      body.compress = true;
+    }
+    if (maxContextTokens !== void 0) {
+      body.max_context_tokens = maxContextTokens;
+    }
+    if (project) {
+      body.project = project;
+    }
+    if (tier) {
+      body.tier = tier;
+    }
+    if (minImportance !== void 0) {
+      body.min_importance = minImportance;
+    }
+    const response = await this.request(
+      "POST",
+      "/v1/memories/search",
+      body
+    );
+    return response.data;
+  }
+  /**
+   * List recent memories with pagination
+   */
+  async listMemories(limit = 20, offset = 0) {
+    return this.request(
+      "GET",
+      `/v1/memories?limit=${limit}&offset=${offset}`
+    );
+  }
+  /**
+   * Get a specific memory by ID
+   */
+  async getMemory(id) {
+    return this.request("GET", `/v1/memories/${id}`);
+  }
+  /**
+   * Update an existing memory
+   */
+  async updateMemory(id, content, metadata) {
+    this.validateContentSize(content);
+    return this.request("PATCH", `/v1/memories/${id}`, {
+      content,
+      metadata
+    });
+  }
+  /**
+   * Delete a memory
+   */
+  async deleteMemory(id) {
+    await this.request("DELETE", `/v1/memories/${id}`);
+  }
+  /**
+   * Create a named entity
+   */
+  async createEntity(name, type, metadata) {
+    this.validateContentSize(name);
+    return this.request("POST", "/v1/entities", {
+      name,
+      type,
+      metadata
+    });
+  }
+  /**
+   * Link an entity to a memory
+   */
+  async linkEntity(entityId, memoryId, relationship = "mentioned_in") {
+    await this.request("POST", "/v1/entities/links", {
+      entity_id: entityId,
+      memory_id: memoryId,
+      relationship
+    });
+  }
+  /**
+   * Get an entity by ID
+   */
+  async getEntity(id) {
+    return this.request("GET", `/v1/entities/${id}`);
+  }
+  /**
+   * List entities with pagination
+   */
+  async listEntities(limit = 20, offset = 0) {
+    return this.request(
+      "GET",
+      `/v1/entities?limit=${limit}&offset=${offset}`
+    );
+  }
+  /**
+   * Get entity neighborhood (ego-centric subgraph).
+   * Returns the entity's 1-hop or 2-hop neighbors and relationships.
+   */
+  async getEntityNeighborhood(entityId, depth = 1, maxNeighbors = 50) {
+    return this.request(
+      "GET",
+      `/v1/entities/${entityId}/neighborhood?depth=${depth}&max_neighbors=${maxNeighbors}`
+    );
+  }
+  /**
+   * Delete an entity
+   */
+  async deleteEntity(id) {
+    await this.request("DELETE", `/v1/entities/${id}`);
+  }
+  /**
+   * List agents with pagination
+   */
+  async listAgents(limit = 20, offset = 0) {
+    return this.request(
+      "GET",
+      `/v1/agents?limit=${limit}&offset=${offset}`
+    );
+  }
+  /**
+   * Create a new agent
+   */
+  async createAgent(name, description, metadata) {
+    const body = { name };
+    if (description) body.description = description;
+    if (metadata) body.metadata = metadata;
+    return this.request("POST", "/v1/agents", body);
+  }
+  /**
+   * Get an agent by ID
+   */
+  async getAgent(id) {
+    return this.request("GET", `/v1/agents/${id}`);
+  }
+  /**
+   * Batch store multiple memories in a single API call.
+   * Uses the /v1/memories/batch endpoint.
+   */
+  async batchStoreMemories(items) {
+    if (items.length === 0) {
+      return { success: true, total: 0, succeeded: 0, failed: 0, skipped: 0, results: [] };
+    }
+    if (items.length > 100) {
+      throw new Error("Batch size exceeds maximum of 100 memories");
+    }
+    const memories = items.map((item) => ({
+      content: item.content,
+      metadata: item.metadata || {},
+      agent_id: item.agent_id || this.config.agentId
+    }));
+    return this.request("POST", "/v1/memories/batch", { memories });
+  }
+  /**
+   * Build a context string from search results.
+   * Searches for relevant memories, formats them, and returns
+   * a single string ready for prompt injection.
+   */
+  async buildContext(query, limit = 10, threshold = 0.5, maxTokens) {
+    const results = await this.searchMemories(
+      query,
+      limit,
+      threshold,
+      void 0,
+      // use default agent
+      false,
+      // no confidential
+      false,
+      // no archived
+      !!maxTokens,
+      // compress if token budget provided
+      maxTokens
+    );
+    if (results.length === 0) {
+      return { context: "", memories_used: 0, total_chars: 0 };
+    }
+    const lines = [];
+    for (const result of results) {
+      const score = (result.score * 100).toFixed(0);
+      lines.push(`[${score}%] ${result.memory.content}`);
+    }
+    const context = lines.join("\n\n");
+    let finalContext = context;
+    if (maxTokens) {
+      const charBudget = maxTokens * 4;
+      if (finalContext.length > charBudget) {
+        finalContext = finalContext.slice(0, charBudget) + "\n\n[...truncated]";
+      }
+    }
+    return {
+      context: finalContext,
+      memories_used: results.length,
+      total_chars: finalContext.length
+    };
+  }
+  /**
+   * Start a new session
+   */
+  async startSession(title, project, metadata) {
+    const body = {};
+    if (this.config.agentId) body.agent_id = this.config.agentId;
+    if (title) body.title = title;
+    if (project) body.project = project;
+    if (metadata) body.metadata = metadata;
+    return this.request("POST", "/v1/sessions", body);
+  }
+  /**
+   * End an active session
+   */
+  async endSession(sessionId, summary) {
+    const body = {};
+    if (summary) body.summary = summary;
+    return this.request("PUT", `/v1/sessions/${sessionId}/end`, body);
+  }
+  /**
+   * Get a session by ID with its memories
+   */
+  async getSession(sessionId) {
+    return this.request(
+      "GET",
+      `/v1/sessions/${sessionId}?include_memories=true`
+    );
+  }
+  /**
+   * List sessions with optional filters
+   */
+  async listSessions(limit = 20, agentId, project, status) {
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    const effectiveAgentId = agentId ?? this.config.agentId;
+    if (effectiveAgentId) params.set("agent_id", effectiveAgentId);
+    if (project) params.set("project", project);
+    if (status) params.set("status", status);
+    return this.request(
+      "GET",
+      `/v1/sessions?${params.toString()}`
+    );
+  }
+  /**
+   * Record a new decision
+   */
+  async recordDecision(title, rationale, alternatives, project, tags, status, metadata) {
+    const body = { title, rationale };
+    if (this.config.agentId) body.agent_id = this.config.agentId;
+    if (alternatives) body.alternatives = alternatives;
+    if (project) body.project_slug = project;
+    if (tags) body.tags = tags;
+    if (status) body.status = status;
+    if (metadata) body.metadata = metadata;
+    return this.request("POST", "/v1/decisions", body);
+  }
+  /**
+   * List decisions with optional filters
+   */
+  async listDecisions(limit, project, status, tags) {
+    const params = new URLSearchParams();
+    if (limit) params.set("limit", String(limit));
+    if (project) params.set("project", project);
+    if (status) params.set("status", status);
+    if (tags) params.set("tags", tags);
+    return this.request(
+      "GET",
+      `/v1/decisions?${params.toString()}`
+    );
+  }
+  /**
+   * Supersede a decision with a new one
+   */
+  async supersedeDecision(decisionId, title, rationale, alternatives, tags) {
+    const body = { title, rationale };
+    if (alternatives) body.alternatives = alternatives;
+    if (tags) body.tags = tags;
+    return this.request(
+      "POST",
+      `/v1/decisions/${decisionId}/supersede`,
+      body
+    );
+  }
+  /**
+   * Check for existing decisions about a topic (semantic search)
+   */
+  async checkDecisions(query, project, limit, threshold, includeSuperseded) {
+    const params = new URLSearchParams();
+    params.set("query", query);
+    if (limit) params.set("limit", String(limit));
+    if (threshold !== void 0) params.set("threshold", String(threshold));
+    if (project) params.set("project", project);
+    if (includeSuperseded) params.set("include_superseded", "true");
+    return this.request(
+      "GET",
+      `/v1/decisions/check?${params.toString()}`
+    );
+  }
+  /**
+   * Register a new project
+   */
+  async createProject(slug, name, description, stack, repo_url, metadata) {
+    const body = { slug, name };
+    if (description) body.description = description;
+    if (stack) body.stack = stack;
+    if (repo_url) body.repo_url = repo_url;
+    if (metadata) body.metadata = metadata;
+    return this.request("POST", "/v1/projects", body);
+  }
+  /**
+   * List projects with optional pagination
+   */
+  async listProjects(limit = 20, cursor) {
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (cursor) params.set("cursor", cursor);
+    return this.request(
+      "GET",
+      `/v1/projects?${params.toString()}`
+    );
+  }
+  /**
+   * Get a project by slug
+   */
+  async getProject(slug) {
+    return this.request("GET", `/v1/projects/${slug}`);
+  }
+  /**
+   * Create a reusable pattern
+   */
+  async createPattern(title, description, category, example_code, scope, tags, source_project, metadata) {
+    const body = { title, description };
+    if (category) body.category = category;
+    if (example_code) body.example_code = example_code;
+    if (scope) body.scope = scope;
+    if (tags) body.tags = tags;
+    if (source_project) body.source_project = source_project;
+    if (metadata) body.metadata = metadata;
+    return this.request("POST", "/v1/patterns", body);
+  }
+  /**
+   * Search patterns using semantic search
+   */
+  async searchPatterns(query, category, project, limit, threshold) {
+    const params = new URLSearchParams();
+    params.set("query", query);
+    if (category) params.set("category", category);
+    if (project) params.set("project", project);
+    if (limit) params.set("limit", String(limit));
+    if (threshold !== void 0) params.set("threshold", String(threshold));
+    return this.request(
+      "GET",
+      `/v1/patterns/search?${params.toString()}`
+    );
+  }
+  /**
+   * Adopt a pattern for a project
+   */
+  async adoptPattern(patternId, project) {
+    return this.request(
+      "POST",
+      `/v1/patterns/${patternId}/adopt`,
+      { project }
+    );
+  }
+  /**
+   * Suggest patterns for a project
+   */
+  async suggestPatterns(project, limit) {
+    const params = new URLSearchParams();
+    params.set("project", project);
+    if (limit) params.set("limit", String(limit));
+    return this.request(
+      "GET",
+      `/v1/patterns/suggest?${params.toString()}`
+    );
+  }
+  // ── Project Relationships (Issue #186) ──
+  /**
+   * Add a relationship between two projects
+   */
+  async addProjectRelationship(sourceSlug, targetProject, relationshipType, metadata) {
+    const body = {
+      target_project: targetProject,
+      relationship_type: relationshipType
+    };
+    if (metadata) body.metadata = metadata;
+    return this.request(
+      "POST",
+      `/v1/projects/${sourceSlug}/relationships`,
+      body
+    );
+  }
+  /**
+   * Get what this project depends on
+   */
+  async getProjectDependencies(slug) {
+    return this.request(
+      "GET",
+      `/v1/projects/${slug}/dependencies`
+    );
+  }
+  /**
+   * Get what depends on this project
+   */
+  async getProjectDependents(slug) {
+    return this.request(
+      "GET",
+      `/v1/projects/${slug}/dependents`
+    );
+  }
+  /**
+   * Get all related projects
+   */
+  async getProjectRelated(slug) {
+    return this.request(
+      "GET",
+      `/v1/projects/${slug}/related`
+    );
+  }
+  /**
+   * Run impact analysis for a project change
+   */
+  async projectImpactAnalysis(project, changeDescription) {
+    return this.request(
+      "POST",
+      "/v1/projects/impact-analysis",
+      { project, change_description: changeDescription }
+    );
+  }
+  /**
+   * Find patterns shared between two projects
+   */
+  async getSharedPatterns(slugA, slugB) {
+    return this.request(
+      "GET",
+      `/v1/projects/shared-patterns?a=${encodeURIComponent(slugA)}&b=${encodeURIComponent(slugB)}`
+    );
+  }
+  /**
+   * Get full project context (hot memories, decisions, patterns, formatted text)
+   */
+  async getProjectContext(slug) {
+    return this.request(
+      "GET",
+      `/v1/projects/${encodeURIComponent(slug)}/context`
+    );
+  }
+  /**
+   * Promote/demote a memory by updating its importance and tier
+   */
+  async promoteMemory(memoryId, importance, tier) {
+    const body = { importance };
+    if (tier) {
+      body.tier = tier;
+    }
+    return this.request(
+      "PUT",
+      `/v1/memories/${encodeURIComponent(memoryId)}/importance`,
+      body
+    );
+  }
+  /**
+   * Health check - verify API connectivity
+   */
+  async healthCheck() {
+    try {
+      await this.request("GET", "/v1/health");
+      return {
+        status: "healthy",
+        message: "API connection successful"
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      return {
+        status: "unhealthy",
+        message: `API connection failed: ${errorMsg}`
+      };
+    }
+  }
+};
+
+export {
+  getEnabledTools,
+  loadConfig,
+  getAgentId,
+  initLogger,
+  getLogger,
+  MemoryRelayClient
+};
+//# sourceMappingURL=chunk-P6TZEH6O.js.map