@anuma/sdk 1.0.0 → 1.1.0

package/dist/server/chunk-RCCKRTBI.mjs

@@ -0,0 +1,230 @@
+import {
+  BASE_URL
+} from "./chunk-FMGZTVXQ.mjs";
+
+// src/lib/logger.ts
+var consoleLogger = {
+  debug: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+
+// src/lib/memory/portalLlm.ts
+function defaultBaseUrl() {
+  return typeof process !== "undefined" && process.env?.ANUMA_PORTAL_BASE_URL || BASE_URL;
+}
+var RESPONSE_FORMAT_OK = /* @__PURE__ */ new Set(["openai", "inclusionai", "deepseek"]);
+var RESPONSE_SCHEMA_OK = /* @__PURE__ */ new Set(["openai"]);
+function supportsResponseFormat(model, variant = "json_object") {
+  const allow = variant === "json_schema" ? RESPONSE_SCHEMA_OK : RESPONSE_FORMAT_OK;
+  return model.split("/").some((seg) => allow.has(seg));
+}
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([408, 409, 425, 429]);
+function isRetryableStatus(status) {
+  return status >= 500 || RETRYABLE_HTTP.has(status);
+}
+function parseRetryAfterMs(header) {
+  if (!header) return null;
+  const secs = Number(header);
+  if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+  const dateMs = Date.parse(header);
+  if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
+  return null;
+}
+function defaultBackoffMs(attempt) {
+  const base = Math.min(2e3, 250 * 2 ** (attempt - 1));
+  return base + Math.floor(Math.random() * 100);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function resolvePortalAuthHeaders(auth, tag) {
+  if (auth.apiKey) {
+    return { "x-api-key": auth.apiKey };
+  }
+  if (auth.getToken) {
+    let token;
+    try {
+      token = await auth.getToken();
+    } catch (err) {
+      getLogger().warn(`[${tag}] getToken threw`, err);
+      return null;
+    }
+    if (!token) {
+      getLogger().warn(`[${tag}] getToken returned no token`);
+      return null;
+    }
+    return { Authorization: `Bearer ${token}` };
+  }
+  throw new Error(`[${tag}] Either apiKey or getToken must be provided`);
+}
+async function callPortalJsonCompletion(req) {
+  const log = getLogger();
+  const maxAttempts = Math.max(1, req.maxAttempts ?? 3);
+  const startedAt = Date.now();
+  const overBudget = () => req.totalTimeoutMs !== void 0 && Date.now() - startedAt >= req.totalTimeoutMs;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1 && overBudget()) {
+      log.warn(`[${req.tag}] over time budget before attempt ${attempt}, giving up`);
+      break;
+    }
+    const attemptReq = req.totalTimeoutMs !== void 0 ? {
+      ...req,
+      timeoutMs: Math.max(
+        1,
+        Math.min(req.timeoutMs ?? 6e4, req.totalTimeoutMs - (Date.now() - startedAt))
+      )
+    } : req;
+    const outcome = await attemptPortalJson(attemptReq);
+    if (outcome.kind === "ok") return outcome.value;
+    if (outcome.kind === "terminal") {
+      log.warn(`[${req.tag}] ${outcome.reason}`);
+      return null;
+    }
+    if (attempt >= maxAttempts) {
+      log.warn(`[${req.tag}] ${outcome.reason} \u2014 attempt ${attempt}/${maxAttempts}, giving up`);
+      break;
+    }
+    const backoff = (req.backoffMs ?? defaultBackoffMs)(attempt);
+    const delay = Math.max(backoff, outcome.retryAfterMs ?? 0);
+    if (overBudget() || req.totalTimeoutMs !== void 0 && Date.now() - startedAt + delay >= req.totalTimeoutMs) {
+      log.warn(
+        `[${req.tag}] ${outcome.reason} \u2014 attempt ${attempt}/${maxAttempts}, over time budget, giving up`
+      );
+      break;
+    }
+    log.warn(`[${req.tag}] ${outcome.reason} \u2014 attempt ${attempt}/${maxAttempts}, retrying`);
+    if (delay > 0) await sleep(delay);
+  }
+  return null;
+}
+async function attemptPortalJson(req) {
+  const baseUrl = req.baseUrl ?? defaultBaseUrl();
+  const fetchImpl = req.fetchFn ?? fetch;
+  const timeoutMs = req.timeoutMs ?? 6e4;
+  const authHeaders = await resolvePortalAuthHeaders(req, req.tag);
+  if (authHeaders === null) return { kind: "terminal", reason: "auth unavailable (no token)" };
+  const isAnthropic = req.model.startsWith("anthropic/");
+  const prefill = isAnthropic ? "{" : "";
+  const messages = [
+    { role: "system", content: req.systemPrompt },
+    { role: "user", content: req.userMessage }
+  ];
+  if (prefill) messages.push({ role: "assistant", content: prefill });
+  const supportsJsonObjectFormat = supportsResponseFormat(req.model);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const requestBody = {
+    model: req.model,
+    messages,
+    ...supportsJsonObjectFormat && { response_format: { type: "json_object" } },
+    ...req.extra
+  };
+  if (!supportsJsonObjectFormat) delete requestBody.response_format;
+  let response;
+  try {
+    response = await fetchImpl(`${baseUrl}/api/v1/chat/completions`, {
+      method: "POST",
+      headers: { ...authHeaders, "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    return { kind: "retryable", reason: `fetch failed: ${err.message}` };
+  }
+  if (!response.ok) {
+    clearTimeout(timer);
+    const reason = `portal returned ${response.status}`;
+    if (response.status === 401) {
+      const tokenAuth = !req.apiKey && !!req.getToken;
+      return tokenAuth ? { kind: "retryable", reason: `${reason} (token may be expired; refreshing)` } : { kind: "terminal", reason };
+    }
+    if (!isRetryableStatus(response.status)) return { kind: "terminal", reason };
+    const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+    return retryAfterMs !== null ? { kind: "retryable", reason, retryAfterMs } : { kind: "retryable", reason };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (err) {
+    clearTimeout(timer);
+    return { kind: "retryable", reason: `response body parse failed: ${err.message}` };
+  }
+  clearTimeout(timer);
+  const rawContent = extractCompletionContent(body);
+  if (!rawContent) {
+    return { kind: "retryable", reason: "portal response had no completion content" };
+  }
+  const looksLikeContinuation = prefill && /^\s*"/.test(rawContent);
+  const content = looksLikeContinuation ? prefill + rawContent : rawContent;
+  const candidate = extractJsonCandidate(content);
+  let value;
+  try {
+    value = JSON.parse(candidate);
+  } catch (err) {
+    return {
+      kind: "retryable",
+      reason: `completion was not valid JSON: ${err.message}`
+    };
+  }
+  if (value === null) {
+    return { kind: "retryable", reason: "completion parsed to null" };
+  }
+  return { kind: "ok", value };
+}
+function extractJsonCandidate(raw) {
+  const trimmed = raw.trim();
+  const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const body = fence ? fence[1].trim() : trimmed;
+  const start = body.search(/[{[]/);
+  if (start < 0) return body;
+  const open = body[start];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < body.length; i++) {
+    const ch = body[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return body.slice(start, i + 1);
+    }
+  }
+  return body;
+}
+function extractCompletionContent(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const choices = body.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return null;
+  const first = choices[0];
+  const content = first?.message?.content;
+  return typeof content === "string" ? content : null;
+}
+
+export {
+  getLogger,
+  supportsResponseFormat,
+  resolvePortalAuthHeaders,
+  callPortalJsonCompletion,
+  extractJsonCandidate
+};

package/dist/server/clientConfig-GMADOBPK.mjs

@@ -0,0 +1,12 @@
+import {
+  BASE_URL,
+  MCP_R2_DOMAIN,
+  createClientConfig,
+  resolveBaseUrl
+} from "./chunk-FMGZTVXQ.mjs";
+export {
+  BASE_URL,
+  MCP_R2_DOMAIN,
+  createClientConfig,
+  resolveBaseUrl
+};

package/dist/server/consolidate-A2ZIX5WF.mjs

@@ -0,0 +1,131 @@
+import {
+  resolvePiiRedactor
+} from "./chunk-PXN5Q3MD.mjs";
+import {
+  callPortalJsonCompletion,
+  getLogger
+} from "./chunk-RCCKRTBI.mjs";
+import "./chunk-FMGZTVXQ.mjs";
+
+// src/lib/memory/consolidate.ts
+var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
+var DEFAULT_CONSOLIDATE_ATTEMPTS = 3;
+var DEFAULT_CONSOLIDATE_TOTAL_TIMEOUT_MS = 2e4;
+var SYSTEM_PROMPT = `You consolidate a new memory against existing memories from the same user.
+
+A "memory" is a self-contained natural-language fact about the user. Multiple memories about the same EXACT FACET (the same dimension of the same subject) should never coexist \u2014 they should be merged into one. Different facets on the same subject (e.g. user's dog's name vs user's dog's age) are SEPARATE memories.
+
+Decide one of three actions:
+
+- "create": the new memory describes a distinct fact not covered by any existing memory. Write it as new.
+- "update": the new memory describes the SAME FACET as exactly one existing memory. Either it adds detail, corrects a value, or rephrases the same fact. Return targetId of that existing memory + the consolidated content (richest version of the two).
+- "noop": the new memory is already fully captured by an existing memory \u2014 same facet, no new information. Skip the write.
+
+RULES (carry these strictly):
+
+1. ONE OBSERVATION PER DISTINCT FACET. If the new memory is about "user's aunt's twins" and an existing memory is also about "user's aunt's twins", they are the same facet \u2192 update, never create.
+2. MATCH BY FACET, NOT TOPIC. Two memories both mentioning "Zara" is not enough to merge \u2014 only merge if they describe the same property (e.g. both about "user's pending Zara boot exchange"). Two memories about Zara on different topics (e.g. "user shops at Zara" + "user returned a sweater to Zara last week") are separate facets.
+3. NO COMPUTATION. Do not sum counts, decrement quantities, or derive new facts from existing ones. If the new memory says "user spent $200 today" and an existing memory says "user spent $150 yesterday", these are TWO SEPARATE EVENTS \u2014 create.
+4. Events with different occurredAt dates are different memories even if the same activity ("user went to gym Monday" vs "user went to gym Friday" \u2014 separate events).
+5. When in doubt between create and update, choose create. Over-merging loses information; under-merging is recoverable.
+
+OUTPUT \u2014 strict JSON, no prose:
+{
+  "action": "create" | "update" | "noop",
+  "targetId": "<existing memory id, required for update/noop, omit for create>",
+  "content": "<consolidated content, required for create/update, omit for noop>"
+}
+
+For "create": content is the new memory verbatim (or a slight refinement).
+For "update": content is the merged richest-version, \u226480 words.
+For "noop": no content (existing memory is already correct).`;
+async function consolidateMemory(newContent, candidates, options) {
+  const fallback = {
+    action: "create",
+    content: newContent
+  };
+  const trimmed = newContent.trim();
+  if (trimmed.length === 0) return fallback;
+  if (candidates.length === 0) return fallback;
+  const redactor = resolvePiiRedactor(options.piiRedaction);
+  const safeTrimmed = redactor ? redactor.redactText(trimmed).text : trimmed;
+  const candidateText = candidates.map((c, i) => {
+    const safeContent = redactor ? redactor.redactText(c.content).text : c.content;
+    return `[${i + 1}] (id: ${c.id}, sim: ${c.similarity.toFixed(2)})
+  ${safeContent}`;
+  }).join("\n");
+  const userMessage = `New memory:
+  ${safeTrimmed}
+
+Existing memories (top ${candidates.length} by cosine):
+${candidateText}`;
+  let parsed;
+  try {
+    parsed = await callPortalJsonCompletion({
+      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
+      ...options.getToken !== void 0 && { getToken: options.getToken },
+      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
+      model: options.model ?? DEFAULT_MODEL,
+      systemPrompt: SYSTEM_PROMPT,
+      userMessage,
+      tag: "memory/consolidate",
+      // Retry TRANSIENT failures only (network/timeout/5xx/429/empty) before
+      // degrading to create — a transient blip would otherwise leave a
+      // permanent below-floor paraphrase that never self-heals (see
+      // DEFAULT_CONSOLIDATE_ATTEMPTS). The happy path still resolves in one
+      // attempt; terminal failures (400/auth) and schema violations never
+      // retry. A total budget keeps a hanging portal from stalling retain.
+      maxAttempts: options.maxAttempts ?? DEFAULT_CONSOLIDATE_ATTEMPTS,
+      totalTimeoutMs: options.totalTimeoutMs ?? DEFAULT_CONSOLIDATE_TOTAL_TIMEOUT_MS,
+      ...options.backoffMs && { backoffMs: options.backoffMs },
+      ...options.fetchFn && { fetchFn: options.fetchFn }
+    });
+  } catch (err) {
+    return degrade("llm_error", fallback, options, err);
+  }
+  if (parsed === null) return degrade("llm_error", fallback, options);
+  const validIds = new Set(candidates.map((c) => c.id));
+  const result = validate(parsed, trimmed, validIds);
+  if (!result) return degrade("invalid_response", fallback, options);
+  if (redactor && result.content !== void 0) {
+    const restored = redactor.restoreForStorage(result.content);
+    if (restored.unresolved) {
+      return degrade("invalid_response", fallback, options);
+    }
+    return { ...result, content: restored.text };
+  }
+  return result;
+}
+function degrade(reason, fallback, options, detail) {
+  if (detail !== void 0) {
+    getLogger().warn(`memory/consolidate: degraded to create (${reason})`, detail);
+  } else {
+    getLogger().warn(`memory/consolidate: degraded to create (${reason})`);
+  }
+  try {
+    options.onFallback?.(reason);
+  } catch {
+  }
+  return { ...fallback, fallbackReason: reason };
+}
+function validate(parsed, newContent, validIds) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  const action = obj.action;
+  if (action !== "create" && action !== "update" && action !== "noop") return null;
+  if (action === "create") {
+    const c2 = typeof obj.content === "string" ? obj.content.trim() : "";
+    return { action: "create", content: c2.length > 0 ? c2 : newContent };
+  }
+  const targetId = typeof obj.targetId === "string" ? obj.targetId : null;
+  if (!targetId || !validIds.has(targetId)) return null;
+  if (action === "noop") {
+    return { action: "noop", targetId };
+  }
+  const c = typeof obj.content === "string" ? obj.content.trim() : "";
+  if (c.length === 0) return null;
+  return { action: "update", targetId, content: c };
+}
+export {
+  consolidateMemory
+};