@engramind/client 0.0.0-stage → 0.1.1

package/dist/server.js

@@ -0,0 +1,553 @@
+import {
+  EngramindError,
+  clientStatus,
+  createConsumptionGrouper,
+  engramindCodeOf,
+  isConsumedEvent,
+  isMemoryChange,
+  mergeConsumption,
+  notConfiguredError,
+  proxyMaskedError,
+  toEngramindError,
+  toLiveEvent,
+  unreachableError
+} from "./chunk-THVEWMKQ.js";
+
+// src/server/client.ts
+import { randomUUID } from "crypto";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var USER_TEXT_QUERY = ["focus"];
+var enc = encodeURIComponent;
+function buildUrl(baseUrl, path, query = {}) {
+  const url = new URL(`${baseUrl.replace(/\/+$/, "")}${path}`);
+  for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== null && value !== "") url.searchParams.set(key, String(value));
+  return url.toString();
+}
+function debugUrl(url) {
+  const masked = new URL(url);
+  for (const key of USER_TEXT_QUERY) {
+    const value = masked.searchParams.get(key);
+    if (value !== null) masked.searchParams.set(key, `[omitido: ${value.length} caracteres]`);
+  }
+  return masked.toString();
+}
+function createEngramindClient(options) {
+  const doFetch = options.fetch ?? fetch;
+  const userAgent = options.userAgent ?? "engramind-client";
+  async function call(method, path, request = {}) {
+    const headers = { ...request.headers, Authorization: `Bearer ${options.token}`, Accept: "application/json", "User-Agent": userAgent };
+    if (method !== "GET") headers["Idempotency-Key"] = request.idempotencyKey ?? `engramind-client-${randomUUID()}`;
+    const hasBody = request.body !== void 0 && method !== "GET";
+    if (hasBody) headers["Content-Type"] = "application/json";
+    const timeout = AbortSignal.timeout(request.timeoutMs ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const signal = request.signal ? AbortSignal.any([request.signal, timeout]) : timeout;
+    const url = buildUrl(options.baseUrl, path, request.query);
+    const started = Date.now();
+    let res;
+    try {
+      res = await doFetch(url, { method, headers, body: hasBody ? JSON.stringify(request.body) : void 0, cache: "no-store", signal });
+    } catch (error) {
+      const reason = error instanceof Error ? error.name === "TimeoutError" || error.name === "AbortError" ? "tempo limite" : error.cause?.code ?? error.message : String(error);
+      options.onDebug?.({ method, url: debugUrl(url), status: null, durationMs: Date.now() - started, error: reason });
+      throw unreachableError(reason);
+    }
+    options.onDebug?.({ method, url: debugUrl(url), status: res.status, durationMs: Date.now() - started });
+    if (res.status === 304) return null;
+    const text = await res.text();
+    let json2 = null;
+    if (text) {
+      try {
+        json2 = JSON.parse(text);
+      } catch {
+        json2 = null;
+      }
+    }
+    if (!res.ok) {
+      const body = json2?.error ?? null;
+      throw toEngramindError(res.status, body && typeof body === "object" ? body : null, res.headers.get("retry-after"), body ? null : proxyMaskedError(text, json2));
+    }
+    return json2;
+  }
+  async function ready(signal) {
+    try {
+      const res = await doFetch(`${options.baseUrl.replace(/\/+$/, "")}/health/ready`, { headers: { Accept: "application/json", "User-Agent": userAgent }, cache: "no-store", signal: signal ?? AbortSignal.timeout(1e4) });
+      const body = await res.json().catch(() => null);
+      return { ready: res.ok && body?.status === "ready", detail: body?.status ?? `HTTP ${res.status}` };
+    } catch (error) {
+      return { ready: false, detail: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  return {
+    call,
+    ready,
+    whoami: () => call("GET", "/v1/whoami"),
+    consumerSettings: () => call("GET", "/v1/consumer-settings"),
+    categories: {
+      list: () => call("GET", "/v1/categories"),
+      create: (input) => call("POST", "/v1/categories", { body: input })
+    },
+    agents: {
+      list: (query = {}) => call("GET", "/v1/agents", { query }),
+      get: (agent) => call("GET", `/v1/agents/${enc(agent)}`),
+      create: (input) => call("POST", "/v1/agents", { body: input }),
+      update: (agent, input) => call("PATCH", `/v1/agents/${enc(agent)}`, { body: input }),
+      delete: (agent) => call("DELETE", `/v1/agents/${enc(agent)}`)
+    },
+    subscriptions: {
+      list: (query = {}) => call("GET", "/v1/subscriptions", { query }),
+      create: (input) => call("POST", "/v1/subscriptions", { body: input }),
+      update: (subscription, input) => call("PATCH", `/v1/subscriptions/${enc(subscription)}`, { body: input }),
+      delete: (subscription) => call("DELETE", `/v1/subscriptions/${enc(subscription)}`)
+    },
+    channels: {
+      list: (query = {}) => call("GET", "/v1/channels", { query }),
+      get: (channel) => call("GET", `/v1/channels/${enc(channel)}`),
+      archive: (channel) => call("POST", `/v1/channels/${enc(channel)}/archive`, { body: {} }),
+      restore: (channel) => call("POST", `/v1/channels/${enc(channel)}/restore`, { body: {} })
+    },
+    memories: {
+      list: (query = {}) => call("GET", "/v1/memories", { query }),
+      get: (memory) => call("GET", `/v1/memories/${enc(memory)}`),
+      create: (input) => call("POST", "/v1/memories", { body: input }),
+      update: (memory, input) => call("PATCH", `/v1/memories/${enc(memory)}`, { body: input }),
+      delete: (memory) => call("DELETE", `/v1/memories/${enc(memory)}`),
+      archive: (memory) => call("POST", `/v1/memories/${enc(memory)}/archive`, { body: {} }),
+      restore: (memory) => call("POST", `/v1/memories/${enc(memory)}/restore`, { body: {} }),
+      pin: (memory) => call("POST", `/v1/memories/${enc(memory)}/pin`, { body: {} }),
+      unpin: (memory) => call("POST", `/v1/memories/${enc(memory)}/unpin`, { body: {} }),
+      move: (memory, channel) => call("POST", `/v1/memories/${enc(memory)}/move`, { body: { channel } }),
+      history: (memory, query = {}) => call("GET", `/v1/memories/${enc(memory)}/history`, { query }),
+      revert: (memory, version) => call("POST", `/v1/memories/${enc(memory)}/revert`, { body: { version } }),
+      import: (input, idempotencyKey) => call("POST", "/v1/memories/import", { body: input, idempotencyKey }),
+      search: (input) => call("POST", "/v1/memories/search", { body: input })
+    },
+    hints: (input) => call("POST", "/v1/hints", { body: input }),
+    context: (input, request = {}) => call("GET", "/v1/context", { query: { channels: input.channels?.join(","), format: input.format, focus: input.focus }, headers: input.ifNoneMatch ? { "If-None-Match": `"${input.ifNoneMatch}"` } : void 0, ...request }),
+    tokens: {
+      list: (query = {}) => call("GET", "/v1/tokens", { query }),
+      issue: (input) => call("POST", "/v1/tokens", { body: input }),
+      update: (token, input) => call("PATCH", `/v1/tokens/${enc(token)}`, { body: input }),
+      revoke: (token) => call("POST", `/v1/tokens/${enc(token)}/revoke`, { body: {} }),
+      rotate: (token) => call("POST", `/v1/tokens/${enc(token)}/rotate`, { body: {} })
+    },
+    apps: {
+      get: (app) => call("GET", `/v1/apps/${enc(app)}`),
+      /** `update_app_webhook`: grava ou remove (com `null`) a URL e o segredo do webhook do app. */
+      updateWebhook: (app, input) => call("PUT", `/v1/apps/${enc(app)}/webhook`, { body: input })
+    }
+  };
+}
+
+// src/server/routes.ts
+var BOTH = ["app", "manager"];
+var MANAGER = ["manager"];
+var r = (method, pattern, operation, modes = BOTH) => ({ method, pattern, operation, modes });
+var PROXY_ROUTES = [
+  r("GET", "whoami", "whoami"),
+  r("GET", "consumer-settings", "get_consumer_settings"),
+  r("GET", "categories", "list_categories"),
+  r("POST", "categories", "create_category"),
+  r("GET", "agents", "list_agents"),
+  r("POST", "agents", "create_agent"),
+  r("GET", "agents/:agent", "get_agent"),
+  r("PATCH", "agents/:agent", "update_agent"),
+  r("DELETE", "agents/:agent", "delete_agent"),
+  r("GET", "subscriptions", "list_subscriptions"),
+  r("POST", "subscriptions", "subscribe"),
+  r("PATCH", "subscriptions/:subscription", "update_subscription"),
+  r("DELETE", "subscriptions/:subscription", "unsubscribe"),
+  r("GET", "channels", "list_channels"),
+  r("GET", "channels/:channel", "get_channel"),
+  r("GET", "channels/:channel/stats", "channel_stats"),
+  r("POST", "channels/:channel/archive", "archive_channel"),
+  r("POST", "channels/:channel/restore", "restore_channel"),
+  r("GET", "memories", "list_memories"),
+  r("POST", "memories", "create_memory"),
+  r("POST", "memories/import", "import_memories"),
+  r("POST", "memories/search", "search_memories"),
+  r("POST", "hints", "get_hints"),
+  r("GET", "memories/:memory", "get_memory"),
+  r("PATCH", "memories/:memory", "update_memory"),
+  r("DELETE", "memories/:memory", "delete_memory"),
+  r("GET", "memories/:memory/history", "memory_history"),
+  r("POST", "memories/:memory/archive", "archive_memory"),
+  r("POST", "memories/:memory/restore", "restore_memory"),
+  r("POST", "memories/:memory/pin", "pin_memory"),
+  r("POST", "memories/:memory/unpin", "unpin_memory"),
+  r("POST", "memories/:memory/move", "move_memory"),
+  r("POST", "memories/:memory/revert", "revert_memory"),
+  r("POST", "memories/:memory/verify", "mark_verified"),
+  r("GET", "tokens", "list_tokens"),
+  r("POST", "tokens", "issue_token"),
+  r("PATCH", "tokens/:token", "update_token"),
+  r("POST", "tokens/:token/revoke", "revoke_token"),
+  r("POST", "tokens/:token/rotate", "rotate_token"),
+  r("GET", "apps/:app", "get_app"),
+  r("PUT", "apps/:app/webhook", "update_app_webhook"),
+  r("GET", "context", "get_context"),
+  // Só o gestor (token admin).
+  r("GET", "apps", "list_apps", MANAGER),
+  r("POST", "channels", "create_channel", MANAGER),
+  r("PATCH", "channels/:channel", "update_channel", MANAGER),
+  r("DELETE", "channels/:channel", "delete_channel", MANAGER),
+  r("GET", "channels/:channel/settings", "get_channel_settings", MANAGER),
+  r("PUT", "channels/:channel/settings", "update_channel_settings", MANAGER),
+  r("GET", "settings", "get_settings", MANAGER)
+];
+function matchProxyRoute(method, segments, mode) {
+  const upper = method.toUpperCase();
+  for (const route of PROXY_ROUTES) {
+    if (route.method !== upper || !route.modes.includes(mode)) continue;
+    const parts = route.pattern.split("/");
+    if (parts.length !== segments.length) continue;
+    const params = {};
+    let ok = true;
+    for (let index = 0; index < parts.length; index += 1) {
+      const part = parts[index];
+      const segment = segments[index];
+      if (part.startsWith(":")) {
+        if (!segment) ok = false;
+        else params[part.slice(1)] = segment;
+      } else if (part !== segment) ok = false;
+      if (!ok) break;
+    }
+    if (ok) return { route, params, path: `/v1/${segments.map((segment) => encodeURIComponent(segment)).join("/")}` };
+  }
+  return null;
+}
+
+// src/server/proxy.ts
+var json = (status, body, headers = {}) => new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json", "Cache-Control": "no-store", ...headers } });
+function errorResponse(error) {
+  if (error instanceof EngramindError) {
+    const headers = error.retryAfter !== null ? { "Retry-After": String(error.retryAfter) } : {};
+    return json(error.status || 500, { success: false, error: error.message, code: error.code, ...error.details !== void 0 ? { details: error.details } : {} }, headers);
+  }
+  return json(500, { success: false, error: "Falha inesperada ao falar com o Engramind.", code: "ENGRAMIND_PROXY_ERROR" });
+}
+function proxySegments(pathname, basePath) {
+  const base = basePath.replace(/\/+$/, "");
+  if (!pathname.startsWith(`${base}/`) && pathname !== base) return null;
+  const rest = pathname.slice(base.length).replace(/^\/+/, "");
+  if (!rest) return [];
+  try {
+    return rest.split("/").map((segment) => decodeURIComponent(segment));
+  } catch {
+    return null;
+  }
+}
+async function readBody(request) {
+  const text = await request.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new EngramindError(400, "Corpo da requisi\xE7\xE3o inv\xE1lido (JSON).", "ENGRAMIND_VALIDATION_ERROR");
+  }
+}
+function createEngramindProxy(options) {
+  const mode = options.mode ?? "app";
+  return async function handle(request) {
+    const url = new URL(request.url);
+    const segments = proxySegments(url.pathname, options.basePath);
+    const match = segments ? matchProxyRoute(request.method, segments, mode) : null;
+    if (!match) return json(404, { success: false, error: "Opera\xE7\xE3o do Engramind n\xE3o dispon\xEDvel neste app.", code: "ENGRAMIND_ROUTE_NOT_ALLOWED" });
+    try {
+      const client = typeof options.client === "function" ? await options.client() : options.client;
+      if (!client) throw notConfiguredError();
+      const method = match.route.method;
+      let body = method === "GET" || method === "DELETE" ? void 0 : await readBody(request);
+      if (match.route.operation === "issue_token" && mode === "app") {
+        const input = body && typeof body === "object" ? body : {};
+        if (input.kind !== void 0 && input.kind !== "agent") throw new EngramindError(403, "O app s\xF3 emite tokens de agente.", "ENGRAMIND_SCOPE_REQUIRED");
+        body = { ...input, kind: "agent" };
+      }
+      const query = Object.fromEntries(url.searchParams.entries());
+      const result = await client.call(method, match.path, { query, body: body ?? (method === "GET" || method === "DELETE" ? void 0 : {}), headers: method === "GET" && request.headers.get("if-none-match") ? { "If-None-Match": request.headers.get("if-none-match") } : void 0 });
+      if (method !== "GET") {
+        const issued = (match.route.operation === "issue_token" || match.route.operation === "rotate_token") && result && typeof result === "object" ? result : null;
+        if (issued && typeof issued.secret === "string" && issued.token) {
+          const token = issued.token;
+          await options.onTokenIssued?.(issued.secret, { id: token.id, kind: token.kind, app: token.app?.slug ?? null, agent: token.agent && token.app ? `${token.app.slug}/${token.agent.slug}` : token.agent?.slug ?? null, operation: match.route.operation });
+        }
+        try {
+          await options.onMutation?.({ operation: match.route.operation, method, params: match.params, body: redactBody(match.route.operation, body), result: issued ? { ...issued, secret: void 0 } : result });
+        } catch (error) {
+          options.onError?.(error, match.route);
+        }
+      }
+      return json(200, { success: true, data: result });
+    } catch (error) {
+      options.onError?.(error, match.route);
+      return errorResponse(error);
+    }
+  };
+}
+function redactBody(operation, body) {
+  if (operation !== "update_app_webhook" || !body || typeof body !== "object") return body;
+  const copy = { ...body };
+  if (copy.secret) copy.secret = "[segredo omitido]";
+  return copy;
+}
+
+// src/server/webhook.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var WEBHOOK_TOLERANCE_SECONDS = 300;
+function parseSignatureHeader(header) {
+  if (!header) return null;
+  let t = null;
+  const v1 = [];
+  for (const part of header.split(",")) {
+    const [key, ...rest] = part.trim().split("=");
+    const value = rest.join("=");
+    if (key === "t") t = Number(value);
+    if (key === "v1" && value) v1.push(value);
+  }
+  if (t === null || !Number.isFinite(t) || !v1.length) return null;
+  return { t, v1 };
+}
+function signWebhook(secret, timestamp, body) {
+  return createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex");
+}
+function verifyWebhookSignature(header, body, secret, options = {}) {
+  const parsed = parseSignatureHeader(header);
+  if (!parsed || !secret) return false;
+  const now = Math.floor((options.now ?? Date.now()) / 1e3);
+  if (Math.abs(now - parsed.t) > (options.toleranceSeconds ?? WEBHOOK_TOLERANCE_SECONDS)) return false;
+  const expected = Buffer.from(signWebhook(secret, parsed.t, body), "hex");
+  return parsed.v1.some((candidate) => {
+    const given = Buffer.from(candidate, "hex");
+    return given.length === expected.length && timingSafeEqual(given, expected);
+  });
+}
+function createMemoryDedupe(options = {}) {
+  const ttl = options.ttlMs ?? 24 * 60 * 6e4;
+  const max = options.max ?? 1e4;
+  const ids = /* @__PURE__ */ new Map();
+  return {
+    seen(id) {
+      const now = Date.now();
+      for (const [key, at] of ids) {
+        if (now - at <= ttl && ids.size <= max) break;
+        ids.delete(key);
+      }
+      if (ids.has(id)) return true;
+      ids.set(id, now);
+      return false;
+    }
+  };
+}
+function createWebhookHandler(options) {
+  const dedupe = options.dedupe ?? createMemoryDedupe();
+  return async function handle(request) {
+    const body = await request.text();
+    const secret = typeof options.secret === "function" ? await options.secret() : options.secret;
+    if (!secret || !verifyWebhookSignature(request.headers.get("engramind-signature"), body, secret, { toleranceSeconds: options.toleranceSeconds })) return new Response(null, { status: 401 });
+    let event;
+    try {
+      event = JSON.parse(body);
+    } catch {
+      return new Response(null, { status: 400 });
+    }
+    if (!event || typeof event.id !== "string" || typeof event.type !== "string") return new Response(null, { status: 400 });
+    if (await dedupe.seen(event.id)) return Response.json({ ok: true, duplicate: true });
+    try {
+      options.context?.handleEvent(event);
+      await options.bus?.publish(toLiveEvent(event));
+      await options.onEvent?.(event);
+    } catch (error) {
+      options.onError?.(error);
+    }
+    return Response.json({ ok: true });
+  };
+}
+
+// src/server/bus.ts
+function createEventBus(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const deliver = (event) => {
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        options.onError?.(error);
+      }
+    }
+  };
+  const remote = options.broadcaster?.subscribe(deliver);
+  void remote;
+  return {
+    async publish(event) {
+      if (options.broadcaster) await options.broadcaster.publish(event);
+      else deliver(event);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    get size() {
+      return listeners.size;
+    }
+  };
+}
+
+// src/server/sse.ts
+var encoder = new TextEncoder();
+var formatSse = (event, data) => `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+function createSseHandler(options) {
+  const heartbeatMs = options.heartbeatMs ?? 25e3;
+  return function handle(request) {
+    let cleanup = null;
+    const stream = new ReadableStream({
+      start(controller) {
+        const send = (chunk) => {
+          try {
+            controller.enqueue(encoder.encode(chunk));
+          } catch {
+            cleanup?.();
+          }
+        };
+        send(`retry: 3000
+${formatSse("ready", { at: (/* @__PURE__ */ new Date()).toISOString() })}`);
+        const unsubscribe = options.bus.subscribe((event) => {
+          if (options.filter && !options.filter(event, request)) return;
+          send(formatSse("engramind", event));
+        });
+        const timer = setInterval(() => send(": ping\n\n"), heartbeatMs);
+        cleanup = () => {
+          if (!cleanup) return;
+          cleanup = null;
+          clearInterval(timer);
+          unsubscribe();
+          try {
+            controller.close();
+          } catch {
+          }
+        };
+        request.signal.addEventListener("abort", () => cleanup?.(), { once: true });
+      },
+      cancel() {
+        cleanup?.();
+      }
+    });
+    return new Response(stream, { headers: { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache, no-transform", Connection: "keep-alive", "X-Accel-Buffering": "no" } });
+  };
+}
+
+// src/server/context.ts
+function createMemoryContextStore() {
+  const map = /* @__PURE__ */ new Map();
+  return { get: (key) => map.get(key) ?? null, set: (key, entry) => void map.set(key, entry), keys: () => [...map.keys()] };
+}
+var SEP = "\0";
+var contextKey = (agent, channels, format) => [agent, [...channels].sort().join(","), format].join(SEP);
+var channelsOfKey = (key) => (key.split(SEP)[1] ?? "").split(",").filter(Boolean);
+function invalidatesContext(event) {
+  if (isConsumedEvent(event.type)) return false;
+  return event.type.startsWith("memory.") || event.type === "channel.updated" || event.type === "subscription.updated" || event.type === "settings.updated";
+}
+function createContextCache(options) {
+  const store = options.store ?? createMemoryContextStore();
+  const format = options.format ?? "tagged";
+  const maxAge = options.maxAgeMs ?? 5 * 6e4;
+  let allDirty = false;
+  async function markChannels(channels) {
+    const wanted = channels.filter((channel) => Boolean(channel));
+    for (const key of await store.keys()) {
+      const keyChannels = channelsOfKey(key);
+      const hit = !wanted.length || !keyChannels.length || wanted.some((channel) => keyChannels.includes(channel));
+      if (!hit) continue;
+      const entry = await store.get(key);
+      if (entry && !entry.dirty) await store.set(key, { ...entry, dirty: true });
+    }
+  }
+  return {
+    /** Webhook recebido: suja o contexto dos canais afetados (nunca por `memory.consumed`). */
+    handleEvent(event) {
+      if (!invalidatesContext(event)) return;
+      if (!event.channel) allDirty = true;
+      void markChannels(event.channel ? [event.channel] : []);
+    },
+    async getContext(agent, input = {}) {
+      const channels = input.channels ?? [];
+      const key = contextKey(agent, channels, format);
+      const cached = await store.get(key);
+      const usable = cached && !input.focus;
+      if (usable && options.revalidate === "on-dirty" && !cached.dirty && !allDirty && Date.now() - cached.fetchedAt < maxAge) {
+        return { block: cached.content, version: cached.version, source: "live", stale: false, counts: cached.counts, error: null };
+      }
+      try {
+        const client = await options.client(agent);
+        if (!client) throw new Error(`token do agente ${agent} indispon\xEDvel`);
+        const view = await client.context({ channels: channels.length ? [...channels] : void 0, format, focus: input.focus, ifNoneMatch: usable ? cached.version : null });
+        allDirty = false;
+        if (view === null && cached) {
+          await store.set(key, { ...cached, fetchedAt: Date.now(), dirty: false });
+          return { block: cached.content, version: cached.version, source: "live", stale: false, counts: cached.counts, error: null };
+        }
+        if (!view) throw new Error("o Engramind respondeu sem o contexto");
+        const entry = { content: typeof view.content === "string" ? view.content : "", version: view.version ?? "", counts: view.counts, format, fetchedAt: Date.now(), dirty: false };
+        if (!input.focus) await store.set(key, entry);
+        return { block: entry.content, version: entry.version, source: "live", stale: false, counts: entry.counts, error: null };
+      } catch (error) {
+        options.onError?.(error, agent);
+        const reason = error instanceof Error ? error.message : String(error);
+        if (cached) return { block: cached.content, version: cached.version, source: "cache", stale: true, counts: cached.counts, error: reason };
+        return { block: "", version: null, source: "none", stale: true, counts: null, error: reason };
+      }
+    },
+    /** Bloco guardado (sem chamar o Engramind). */
+    peek: async (agent, channels = []) => store.get(contextKey(agent, channels, format))
+  };
+}
+
+// src/server/mcp.ts
+function engramindMcpConfig(input) {
+  const headers = { Authorization: `Bearer ${input.agentToken}` };
+  if (input.channels?.length) headers["Engramind-Channels"] = input.channels.join(",");
+  return { type: "http", url: `${input.baseUrl.replace(/\/+$/, "")}/mcp`, headers };
+}
+var MCP_READ_TOOLS = ["get_context", "search_memories", "get_memory", "get_hints", "list_memories", "list_categories"];
+var MCP_WRITE_TOOLS = ["create_memory", "update_memory"];
+export {
+  EngramindError,
+  MCP_READ_TOOLS,
+  MCP_WRITE_TOOLS,
+  PROXY_ROUTES,
+  WEBHOOK_TOLERANCE_SECONDS,
+  buildUrl,
+  clientStatus,
+  contextKey,
+  createConsumptionGrouper,
+  createContextCache,
+  createEngramindClient,
+  createEngramindProxy,
+  createEventBus,
+  createMemoryContextStore,
+  createMemoryDedupe,
+  createSseHandler,
+  createWebhookHandler,
+  debugUrl,
+  engramindCodeOf,
+  engramindMcpConfig,
+  errorResponse,
+  formatSse,
+  invalidatesContext,
+  isConsumedEvent,
+  isMemoryChange,
+  matchProxyRoute,
+  mergeConsumption,
+  notConfiguredError,
+  parseSignatureHeader,
+  proxyMaskedError,
+  proxySegments,
+  signWebhook,
+  toEngramindError,
+  toLiveEvent,
+  unreachableError,
+  verifyWebhookSignature
+};
+//# sourceMappingURL=server.js.map