@anuma/sdk 1.0.0 → 1.1.1

package/dist/expo/chunk-DFVCS3QQ.mjs

@@ -0,0 +1,246 @@
+import {
+  BASE_URL
+} from "./chunk-GYKJOWEO.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 noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var currentLogger = consoleLogger;
+function setLogger(logger) {
+  currentLogger = logger;
+}
+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 {
+  consoleLogger,
+  noopLogger,
+  setLogger,
+  getLogger,
+  supportsResponseFormat,
+  resolvePortalAuthHeaders,
+  callPortalJsonCompletion,
+  extractJsonCandidate
+};

package/dist/{react/chunk-MJJIYFAX.mjs → expo/chunk-GYKJOWEO.mjs}

@@ -10,7 +10,18 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/clientConfig.ts
-var BASE_URL = "https://portal.anuma-dev.ai";
+var DEFAULT_BASE_URL = "https://portal.anuma-dev.ai";
+function readGlobal(key) {
+  if (typeof globalThis === "undefined") return void 0;
+  const value = globalThis[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function resolveBaseUrl() {
+  const fromProcess = typeof process !== "undefined" ? process.env.API_URL || process.env.NEXT_PUBLIC_API_URL || process.env.EXPO_PUBLIC_API_URL : void 0;
+  const fromGlobal = readGlobal("API_URL") ?? readGlobal("NEXT_PUBLIC_API_URL") ?? readGlobal("EXPO_PUBLIC_API_URL");
+  return (fromProcess || fromGlobal || DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+var BASE_URL = resolveBaseUrl();
 var MCP_R2_DOMAIN = "4cf0e0ea50b97e72386fcf2f92a2d4e8.r2.cloudflarestorage.com";
 var createClientConfig = (config) => ({
   ...config,
@@ -19,6 +30,7 @@ var createClientConfig = (config) => ({
 
 export {
   __decorateClass,
+  resolveBaseUrl,
   BASE_URL,
   MCP_R2_DOMAIN,
   createClientConfig