@anuma/sdk 6.24.1 → 6.25.1

package/dist/expo/{chunk-XDBX4FZY.mjs → chunk-EDABJLYN.mjs}

@@ -1,6 +1,31 @@
 import {
-  getLogger
-} from "./chunk-WUG6GTHO.mjs";
+  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/pii/patterns.ts
 function luhnCheck(digits) {
@@ -641,6 +666,406 @@ function createStreamingDeAnonymizer(redactor, emit) {
   };
 }
 
+// src/lib/chat/endpointOverride.ts
+function validateEndpointOverride(override) {
+  const trimmed = override.trim();
+  if (trimmed === "") {
+    return {
+      valid: false,
+      message: 'endpointOverride must be a non-empty, root-relative path (e.g. "/api/v1/utility/responses"); received an empty or whitespace-only string'
+    };
+  }
+  if (trimmed.startsWith("//") || trimmed.includes("://")) {
+    return {
+      valid: false,
+      message: `endpointOverride must be a root-relative path (e.g. "/api/v1/utility/responses"), not a protocol-relative or absolute URL; received "${trimmed}"`
+    };
+  }
+  return { valid: true, endpoint: trimmed.startsWith("/") ? trimmed : `/${trimmed}` };
+}
+
+// src/lib/internalFlowMarker.ts
+var INTERNAL_FLOW_MARKER = "Anuma internal first-party flow (not user chat).";
+function withInternalFlowMarker(systemPrompt) {
+  if (systemPrompt.includes(INTERNAL_FLOW_MARKER)) return systemPrompt;
+  return `${INTERNAL_FLOW_MARKER}
+${systemPrompt}`;
+}
+
+// src/lib/taskType.ts
+var TASK_TYPE_HEADER = "X-Anuma-Task-Type";
+function taskTypeHeader(taskType) {
+  return taskType ? { [TASK_TYPE_HEADER]: taskType } : {};
+}
+
+// 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"]);
+var JSON_CONTRACT_REMINDER = "Output ONLY the strict JSON object requested. No prose, no explanation, no markdown.";
+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 RESPONSES_ONLY_MODEL_PREFIXES = ["gpt-5.6"];
+function requiresResponsesTransport(model) {
+  return model.split("/").some((seg) => RESPONSES_ONLY_MODEL_PREFIXES.some((prefix) => seg.startsWith(prefix)));
+}
+var CHAT_TO_RESPONSES_FIELDS = {
+  max_completion_tokens: "max_output_tokens"
+};
+function responsesExtra(extra) {
+  if (!extra) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(extra)) {
+    const target = CHAT_TO_RESPONSES_FIELDS[key] ?? key;
+    if (target !== key && target in extra) continue;
+    out[target] = value;
+  }
+  return out;
+}
+var FOREIGN_ENDPOINT_SUFFIX = {
+  chat: "/responses",
+  responses: "/chat/completions"
+};
+function assertTransportMatchesEndpoint(transport, endpoint) {
+  const foreign = FOREIGN_ENDPOINT_SUFFIX[transport];
+  if (!endpoint.endsWith(foreign)) return;
+  throw new Error(
+    `endpointOverride "${endpoint}" is the other transport's endpoint, but transport is "${transport}". The request body is built for the transport, so this sends the wrong shape and 400s without retry.`
+  );
+}
+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();
+  let endpoint = req.transport === "responses" ? "/api/v1/responses" : "/api/v1/chat/completions";
+  if (req.endpointOverride !== void 0) {
+    const overrideValidation = validateEndpointOverride(req.endpointOverride);
+    if (!overrideValidation.valid) {
+      throw new Error(overrideValidation.message);
+    }
+    endpoint = overrideValidation.endpoint;
+    assertTransportMatchesEndpoint(req.transport ?? "chat", endpoint);
+  }
+  const maxAttempts = Math.max(1, req.maxAttempts ?? 3);
+  const startedAt = Date.now();
+  const overBudget = () => req.totalTimeoutMs !== void 0 && Date.now() - startedAt >= req.totalTimeoutMs;
+  let lastFailure;
+  let reinforce = false;
+  const giveUp = () => {
+    req.onFailure?.(lastFailure ?? { reason: "network", attempts: maxAttempts });
+    return null;
+  };
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1 && overBudget()) {
+      log.warn(`[${req.tag}] over time budget before attempt ${attempt}, giving up`);
+      lastFailure = { reason: "time-budget-exhausted", attempts: attempt - 1 };
+      break;
+    }
+    const attemptReq = req.totalTimeoutMs !== void 0 ? {
+      ...req,
+      timeoutMs: Math.max(
+        1,
+        Math.min(req.timeoutMs ?? 6e4, req.totalTimeoutMs - (Date.now() - startedAt))
+      ),
+      ...reinforce && { reinforceJsonContract: true }
+    } : reinforce ? { ...req, reinforceJsonContract: true } : req;
+    const outcome = await attemptPortalJson(attemptReq, endpoint);
+    if (outcome.kind === "ok") {
+      req.onAttempt?.({ attempt, ok: true });
+      return outcome.value;
+    }
+    req.onAttempt?.({
+      attempt,
+      ok: false,
+      reason: outcome.code,
+      ...outcome.httpStatus !== void 0 && { httpStatus: outcome.httpStatus }
+    });
+    lastFailure = {
+      reason: outcome.code,
+      ...outcome.httpStatus !== void 0 && { httpStatus: outcome.httpStatus },
+      attempts: attempt
+    };
+    if (outcome.code === "invalid-json" || outcome.code === "null-completion") reinforce = true;
+    if (outcome.kind === "terminal") {
+      log.warn(`[${req.tag}] ${outcome.reason}`);
+      return giveUp();
+    }
+    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`
+      );
+      lastFailure = { reason: "time-budget-exhausted", attempts: attempt };
+      break;
+    }
+    log.warn(`[${req.tag}] ${outcome.reason} \u2014 attempt ${attempt}/${maxAttempts}, retrying`);
+    if (delay > 0) await sleep(delay);
+  }
+  return giveUp();
+}
+async function attemptPortalJson(req, endpoint) {
+  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", code: "auth-unavailable", reason: "auth unavailable (no token)" };
+  const usesPrefill = req.transport !== "responses" && req.model.startsWith("anthropic/");
+  const prefill = usesPrefill ? "{" : "";
+  const messages = [
+    // Every caller of this helper is a first-party BACKGROUND op (fact extraction,
+    // topic sweep, consolidation, classifiers, graph traversal, query
+    // decomposition). Marking here — the one place they all funnel through — is what
+    // keeps the portal's detector reading them as genuine rather than markerless.
+    // See ../internalFlowMarker.
+    { role: "system", content: withInternalFlowMarker(req.systemPrompt) },
+    // Retry-only. Kept as a SEPARATE message rather than appended to the system
+    // prompt so the marked prompt above stays byte-identical across attempts —
+    // the portal's internal-flow detector reads that one, and rewriting it on a
+    // retry would change what the detector sees for reasons unrelated to auth.
+    ...req.reinforceJsonContract ? [{ role: "system", content: JSON_CONTRACT_REMINDER }] : [],
+    { 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 = req.transport === "responses" ? {
+    model: req.model,
+    // Same system+user pair under the Responses-API field name. No prefill
+    // entry to strip: `usesPrefill` is false on this transport, so it was
+    // never pushed and the response-side restore is disarmed with it. An
+    // earlier version pushed it and sliced it back off here, which left
+    // `prefill` truthy and the restore still armed — the fix belonged at
+    // the decision, not at the two symptoms.
+    input: messages,
+    ...req.reasoning && { reasoning: req.reasoning },
+    // NO response_format. The Responses API spells structured output
+    // differently (`text.format`), and it is unverified against this
+    // portal — so this transport relies on the same strict-JSON system
+    // prompt plus `extractJsonCandidate` that every response_format-
+    // rejecting model already relies on. Verified end to end on dev:
+    // luna returns clean parseable JSON here without it. Add the field
+    // only with a per-provider check, exactly as RESPONSE_FORMAT_OK was
+    // earned.
+    ...responsesExtra(req.extra)
+  } : {
+    model: req.model,
+    messages,
+    ...supportsJsonObjectFormat && { response_format: { type: "json_object" } },
+    ...req.extra
+  };
+  if (req.transport === "responses" || !supportsJsonObjectFormat) {
+    delete requestBody.response_format;
+  }
+  let response;
+  try {
+    response = await fetchImpl(`${baseUrl}${endpoint}`, {
+      method: "POST",
+      // Attached HERE, at the one transport every background memory op shares, so
+      // a new flow gets the provenance by construction rather than by remembering.
+      headers: {
+        ...authHeaders,
+        ...taskTypeHeader(req.taskType),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    return {
+      kind: "retryable",
+      code: "network",
+      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",
+        code: "http-retryable",
+        reason: `${reason} (token may be expired; refreshing)`,
+        httpStatus: response.status
+      } : { kind: "terminal", code: "http-terminal", reason, httpStatus: response.status };
+    }
+    if (!isRetryableStatus(response.status))
+      return { kind: "terminal", code: "http-terminal", reason, httpStatus: response.status };
+    const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+    return {
+      kind: "retryable",
+      code: "http-retryable",
+      reason,
+      httpStatus: response.status,
+      ...retryAfterMs !== null && { retryAfterMs }
+    };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (err) {
+    clearTimeout(timer);
+    return {
+      kind: "retryable",
+      code: "body-parse-failed",
+      reason: `response body parse failed: ${err.message}`
+    };
+  }
+  clearTimeout(timer);
+  logPortalUsage(body, req.tag);
+  const rawContent = extractCompletionContent(body);
+  if (!rawContent) {
+    return {
+      kind: "retryable",
+      code: "empty-content",
+      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",
+      code: "invalid-json",
+      reason: `completion was not valid JSON: ${err.message}`
+    };
+  }
+  if (value === null) {
+    return { kind: "retryable", code: "null-completion", 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 asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function logPortalUsage(body, tag) {
+  try {
+    const root = asRecord(body);
+    if (!root) return;
+    const usage = asRecord(root.usage);
+    const promptTokens = asCount(usage?.prompt_tokens) ?? asCount(usage?.input_tokens);
+    const completionTokens = asCount(usage?.completion_tokens) ?? asCount(usage?.output_tokens);
+    if (promptTokens === void 0 && completionTokens === void 0) return;
+    const cachedTokens = asCount(asRecord(root.portal)?.cached_tokens) ?? asCount(asRecord(usage?.prompt_tokens_details)?.cached_tokens) ?? asCount(asRecord(usage?.input_tokens_details)?.cached_tokens) ?? 0;
+    const reasoningTokens = asCount(asRecord(usage?.output_tokens_details)?.reasoning_tokens) ?? asCount(asRecord(usage?.completion_tokens_details)?.reasoning_tokens);
+    const parts = [];
+    if (promptTokens !== void 0) parts.push(`prompt=${promptTokens}`);
+    if (completionTokens !== void 0) parts.push(`completion=${completionTokens}`);
+    if (reasoningTokens !== void 0) parts.push(`reasoning=${reasoningTokens}`);
+    parts.push(`cached=${cachedTokens}`);
+    getLogger().debug(`[${tag}] usage ${parts.join(" ")}`);
+  } catch {
+  }
+}
+function extractCompletionContent(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const responsesText = extractResponsesContent(body);
+  if (responsesText !== null) return responsesText;
+  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;
+}
+function extractResponsesContent(body) {
+  const root = asRecord(body);
+  if (!root) return null;
+  if (typeof root.output_text === "string" && root.output_text !== "") return root.output_text;
+  if (!Array.isArray(root.output)) return null;
+  const text = root.output.filter((item) => asRecord(item)?.type === "message").flatMap((item) => Array.isArray(item.content) ? item.content : []).map((part) => asRecord(part)?.text).filter((t) => typeof t === "string").join("");
+  return text;
+}
+
 // src/lib/memory/consolidationFallback.ts
 function notifyConsolidationFallback(reason, onFallback, detail) {
   const refused = reason === "subject_mismatch";
@@ -661,10 +1086,24 @@ function notifyConsolidationFallback(reason, onFallback, detail) {
 }
 
 export {
+  consoleLogger,
+  noopLogger,
+  setLogger,
+  getLogger,
   PII_PATTERNS,
   PiiRedactor,
   isPiiRedactor,
   resolvePiiRedactor,
   createStreamingDeAnonymizer,
+  validateEndpointOverride,
+  INTERNAL_FLOW_MARKER,
+  withInternalFlowMarker,
+  taskTypeHeader,
+  supportsResponseFormat,
+  requiresResponsesTransport,
+  resolvePortalAuthHeaders,
+  callPortalJsonCompletion,
+  extractJsonCandidate,
+  extractCompletionContent,
   notifyConsolidationFallback
 };

package/dist/{react/consolidate-XKS6IZFC.mjs → expo/consolidate-5WM3CFKK.mjs}

@@ -1,10 +1,8 @@
 import {
+  callPortalJsonCompletion,
   notifyConsolidationFallback,
   resolvePiiRedactor
-} from "./chunk-GPLMMMZN.mjs";
-import {
-  callPortalJsonCompletion
-} from "./chunk-MHZB6KIX.mjs";
+} from "./chunk-EDABJLYN.mjs";
 import "./chunk-GYKJOWEO.mjs";
 
 // src/lib/memory/consolidate.ts