@anuma/sdk 6.14.2 → 6.15.1

package/dist/expo/index.mjs

@@ -132,7 +132,7 @@ import {
   upsertMessageOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-JA7CDJCA.mjs";
+} from "./chunk-TNMPAE3V.mjs";
 import {
   PII_PATTERNS,
   PiiRedactor,
@@ -140,21 +140,23 @@ import {
   isPiiRedactor,
   notifyConsolidationFallback,
   resolvePiiRedactor
-} from "./chunk-M4JSLFTQ.mjs";
+} from "./chunk-A2G6TRUK.mjs";
 import {
   INTERNAL_FLOW_MARKER,
   callPortalJsonCompletion,
   consoleLogger,
+  extractCompletionContent,
   extractJsonCandidate,
   getLogger,
   noopLogger,
+  requiresResponsesTransport,
   resolvePortalAuthHeaders,
   setLogger,
   supportsResponseFormat,
   taskTypeHeader,
   validateEndpointOverride,
   withInternalFlowMarker
-} from "./chunk-O25LUKBK.mjs";
+} from "./chunk-4Z2X4UYQ.mjs";
 import {
   BASE_URL,
   MCP_R2_DOMAIN,
@@ -6868,7 +6870,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     content: m.content,
     similarity: m.similarity
   }));
-  const { consolidateMemory: doConsolidate } = await import("./consolidate-S3KFA2WT.mjs");
+  const { consolidateMemory: doConsolidate } = await import("./consolidate-ZM5JNULQ.mjs");
   const decision = await doConsolidate(trimmed, candidates, consolidateOptions);
   if (decision.action === "create") return null;
   if (decision.action === "supersede" && decision.content) {
@@ -8092,6 +8094,9 @@ var DEFAULT_BASE_URL = BASE_URL;
 var DEFAULT_MODEL3 = "anthropic/claude-sonnet-4-6";
 var DEFAULT_MAX_TOKENS = 4096;
 var REQUEST_TIMEOUT_MS = 6e4;
+var MIN_RETRY_BUDGET_MS = 2e3;
+var MIN_RESPONSES_OUTPUT_TOKENS = 2048;
+var SCHEMA_FALLBACK_SKIP_STATUSES = /* @__PURE__ */ new Set([401, 403, 404, 408, 409, 413, 425, 429]);
 var DEFAULT_SYSTEM_PROMPT = `You are a personal assistant with access to the user's memory. Answer the user's question using the supplied memories as evidence.
 
 Rules:
@@ -8123,14 +8128,9 @@ ${m.content}`).join("\n\n");
   const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
   const model = options.llmModel ?? DEFAULT_MODEL3;
   const wantsStructured = !!options.responseSchema;
-  const sendResponseFormat = wantsStructured && supportsResponseFormat(model, "json_schema");
+  const useResponsesTransport = requiresResponsesTransport(model);
+  const sendResponseFormat = wantsStructured && !useResponsesTransport && supportsResponseFormat(model, "json_schema");
   const basePrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-  const systemPrompt = wantsStructured && !sendResponseFormat ? `${basePrompt}
-
-Respond with ONLY a single JSON object conforming to this JSON Schema, with no prose, comments, or code fences:
-${JSON.stringify(
-    options.responseSchema
-  )}` : basePrompt;
   const userMessage = [
     `Question:
 ${trimmed}`,
@@ -8140,85 +8140,121 @@ ${evidence}`
   ].join("\n\n");
   const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
   const fetchImpl = options.fetchFn ?? fetch;
+  const buildBody = (useResponseFormat) => {
+    const systemPrompt = wantsStructured && !useResponseFormat ? `${basePrompt}
+
+Respond with ONLY a single JSON object conforming to this JSON Schema, with no prose, comments, or code fences:
+${JSON.stringify(
+      options.responseSchema
+    )}` : basePrompt;
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ];
+    if (useResponsesTransport) {
+      return JSON.stringify({
+        model,
+        // Same system+user pair under the Responses-API field names: `input`
+        // for the turns, `max_output_tokens` for the cap. Sending the
+        // chat-completions spelling here is silently ignored, which caps the
+        // answer at the portal default.
+        input: messages,
+        max_output_tokens: Math.max(maxTokens, MIN_RESPONSES_OUTPUT_TOKENS)
+      });
+    }
+    return JSON.stringify({
+      model,
+      // Modern OpenAI field; the portal reads only `max_completion_tokens`
+      // (the deprecated `max_tokens` is silently ignored → falls back to the
+      // portal's default output cap and truncates the answer).
+      max_completion_tokens: maxTokens,
+      messages,
+      ...useResponseFormat && {
+        response_format: {
+          type: "json_schema",
+          json_schema: { name: "reflect_output", schema: options.responseSchema }
+        }
+      }
+    });
+  };
   const log = getLogger();
   const authHeaders = await resolvePortalAuthHeaders(options, "memory/reflect");
   if (authHeaders === null) return baseResult;
-  const controller = new AbortController();
   const deadline = Date.now() + REQUEST_TIMEOUT_MS;
   const remaining = () => Math.max(0, deadline - Date.now());
-  const timer = setTimeout(() => controller.abort(), remaining());
-  let response;
-  try {
-    response = await fetchImpl(`${baseUrl}/api/v1/chat/completions`, {
-      method: "POST",
-      // No task type unless the caller named one — an undeclared task adds no
-      // header at all, which is what keeps user-facing reflect() unlabelled.
-      headers: {
-        ...authHeaders,
-        ...taskTypeHeader(options.taskType),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model,
-        // Modern OpenAI field; the portal reads only `max_completion_tokens`
-        // (the deprecated `max_tokens` is silently ignored → falls back to the
-        // portal's default output cap and truncates the answer).
-        max_completion_tokens: maxTokens,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userMessage }
-        ],
-        ...sendResponseFormat && {
-          response_format: {
-            type: "json_schema",
-            json_schema: { name: "reflect_output", schema: options.responseSchema }
-          }
-        }
-      }),
-      signal: controller.signal
-    });
-  } catch (err) {
+  const endpoint = useResponsesTransport ? "/api/v1/responses" : "/api/v1/chat/completions";
+  const sendOnce = async (useResponseFormat) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), remaining());
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}${endpoint}`, {
+        method: "POST",
+        // No task type unless the caller named one — an undeclared task adds no
+        // header at all, which is what keeps user-facing reflect() unlabelled.
+        headers: {
+          ...authHeaders,
+          ...taskTypeHeader(options.taskType),
+          "Content-Type": "application/json"
+        },
+        body: buildBody(useResponseFormat),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      log.warn("[memory/reflect] portal request failed", {
+        err: err instanceof Error ? err.message : String(err),
+        baseUrl
+      });
+      return { kind: "error" };
+    }
     clearTimeout(timer);
-    log.warn("[memory/reflect] portal request failed", {
-      err: err instanceof Error ? err.message : String(err),
-      baseUrl
+    if (!response.ok) {
+      return { kind: "http", status: response.status, statusText: response.statusText };
+    }
+    const bodyTimer = setTimeout(() => controller.abort(), remaining());
+    try {
+      const body = await response.json();
+      clearTimeout(bodyTimer);
+      return { kind: "ok", body };
+    } catch (err) {
+      clearTimeout(bodyTimer);
+      log.warn("[memory/reflect] failed to parse portal response body", {
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return { kind: "error" };
+    }
+  };
+  let attempt = await sendOnce(sendResponseFormat);
+  let schemaFallbackUsed = false;
+  const budgetLeftMs = remaining();
+  if (attempt.kind === "http" && sendResponseFormat && !SCHEMA_FALLBACK_SKIP_STATUSES.has(attempt.status) && budgetLeftMs >= MIN_RETRY_BUDGET_MS) {
+    log.warn("[memory/reflect] response_format json_schema rejected; retrying schema-in-prompt", {
+      status: attempt.status,
+      statusText: attempt.statusText,
+      model,
+      taskType: options.taskType,
+      budgetLeftMs
     });
-    return baseResult;
+    schemaFallbackUsed = true;
+    attempt = await sendOnce(false);
   }
-  clearTimeout(timer);
-  if (!response.ok) {
+  if (attempt.kind === "error") return baseResult;
+  if (attempt.kind === "http") {
     log.warn("[memory/reflect] portal returned non-OK", {
-      status: response.status,
-      statusText: response.statusText
+      status: attempt.status,
+      statusText: attempt.statusText,
+      // Distinguishes "the fallback ran and still failed" from "never tried".
+      schemaFallbackUsed
     });
     return baseResult;
   }
-  const bodyTimer = setTimeout(() => controller.abort(), remaining());
-  let body;
-  try {
-    body = await response.json();
-  } catch (err) {
-    clearTimeout(bodyTimer);
-    log.warn("[memory/reflect] failed to parse portal response body", {
-      err: err instanceof Error ? err.message : String(err)
-    });
-    return baseResult;
-  }
-  clearTimeout(bodyTimer);
-  return parseAnswer(body, baseResult, !!options.responseSchema);
+  return parseAnswer(attempt.body, baseResult, !!options.responseSchema);
 }
 function parseAnswer(body, base, parseSchema) {
   if (typeof body !== "object" || body === null) return base;
   const obj = body;
-  const choices = obj.choices;
-  let text12 = "";
-  if (Array.isArray(choices) && choices.length > 0) {
-    const message = choices[0].message;
-    if (typeof message === "object" && message !== null) {
-      const content = message.content;
-      if (typeof content === "string") text12 = content;
-    }
-  }
+  const text12 = extractCompletionContent(obj) ?? "";
   const usage = obj.usage;
   let structuredOutput;
   if (parseSchema && text12) {
@@ -8230,14 +8266,19 @@ function parseAnswer(body, base, parseSchema) {
       });
     }
   }
+  const promptTokens = usage?.prompt_tokens ?? usage?.input_tokens ?? 0;
+  const completionTokens = usage?.completion_tokens ?? usage?.output_tokens ?? 0;
   return {
     text: text12,
     ...structuredOutput !== void 0 && { structuredOutput },
     basedOn: base.basedOn,
     usage: {
-      promptTokens: usage?.prompt_tokens ?? 0,
-      completionTokens: usage?.completion_tokens ?? 0,
-      totalTokens: usage?.total_tokens ?? 0
+      promptTokens,
+      completionTokens,
+      // Derived when absent: the Responses API reports the two component counts
+      // and does not always send a total, which would otherwise report zero
+      // spend for a call that plainly cost something.
+      totalTokens: usage?.total_tokens ?? promptTokens + completionTokens
     }
   };
 }

package/dist/expo/{recall-JYVHWU6N.mjs → recall-FJQTIMYT.mjs}

@@ -1,7 +1,7 @@
 import {
   recall
-} from "./chunk-JA7CDJCA.mjs";
-import "./chunk-O25LUKBK.mjs";
+} from "./chunk-TNMPAE3V.mjs";
+import "./chunk-4Z2X4UYQ.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {
   recall

package/dist/react/{chunk-O25LUKBK.mjs → chunk-4Z2X4UYQ.mjs}

@@ -70,6 +70,34 @@ 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);
@@ -111,13 +139,14 @@ async function resolvePortalAuthHeaders(auth, tag) {
 }
 async function callPortalJsonCompletion(req) {
   const log = getLogger();
-  let endpoint = "/api/v1/chat/completions";
+  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();
@@ -179,8 +208,8 @@ async function attemptPortalJson(req, endpoint) {
   const authHeaders = await resolvePortalAuthHeaders(req, req.tag);
   if (authHeaders === null)
     return { kind: "terminal", code: "auth-unavailable", reason: "auth unavailable (no token)" };
-  const isAnthropic = req.model.startsWith("anthropic/");
-  const prefill = isAnthropic ? "{" : "";
+  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
@@ -199,13 +228,34 @@ async function attemptPortalJson(req, endpoint) {
   const supportsJsonObjectFormat = supportsResponseFormat(req.model);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
-  const requestBody = {
+  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 (!supportsJsonObjectFormat) delete requestBody.response_format;
+  if (req.transport === "responses" || !supportsJsonObjectFormat) {
+    delete requestBody.response_format;
+  }
   let response;
   try {
     response = await fetchImpl(`${baseUrl}${endpoint}`, {
@@ -335,13 +385,15 @@ function logPortalUsage(body, tag) {
     const root = asRecord(body);
     if (!root) return;
     const usage = asRecord(root.usage);
-    const promptTokens = asCount(usage?.prompt_tokens);
-    const completionTokens = asCount(usage?.completion_tokens);
+    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) ?? 0;
+    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 {
@@ -349,12 +401,22 @@ function logPortalUsage(body, tag) {
 }
 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;
+}
 
 export {
   consoleLogger,
@@ -366,7 +428,9 @@ export {
   withInternalFlowMarker,
   taskTypeHeader,
   supportsResponseFormat,
+  requiresResponsesTransport,
   resolvePortalAuthHeaders,
   callPortalJsonCompletion,
-  extractJsonCandidate
+  extractJsonCandidate,
+  extractCompletionContent
 };

package/dist/react/{chunk-2XLHV2XW.mjs → chunk-7X7BNMGS.mjs}

@@ -1,6 +1,6 @@
 import {
   getLogger
-} from "./chunk-O25LUKBK.mjs";
+} from "./chunk-4Z2X4UYQ.mjs";
 
 // src/lib/pii/patterns.ts
 function luhnCheck(digits) {

package/dist/react/{chunk-DNSPMVBY.mjs → chunk-YSL3J4K4.mjs}

@@ -1,7 +1,7 @@
 import {
   callPortalJsonCompletion,
   getLogger
-} from "./chunk-O25LUKBK.mjs";
+} from "./chunk-4Z2X4UYQ.mjs";
 import {
   BASE_URL,
   createClientConfig
@@ -7169,7 +7169,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             subQueries = decomp.subQueries;
           }
         }
-        const { recall: recall2 } = await import("./recall-2BWBJWGG.mjs");
+        const { recall: recall2 } = await import("./recall-UVVZGRVF.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,

package/dist/{expo/consolidate-S3KFA2WT.mjs → react/consolidate-7NMKF7UC.mjs}

@@ -1,10 +1,10 @@
 import {
   notifyConsolidationFallback,
   resolvePiiRedactor
-} from "./chunk-M4JSLFTQ.mjs";
+} from "./chunk-7X7BNMGS.mjs";
 import {
   callPortalJsonCompletion
-} from "./chunk-O25LUKBK.mjs";
+} from "./chunk-4Z2X4UYQ.mjs";
 import "./chunk-GYKJOWEO.mjs";
 
 // src/lib/memory/consolidate.ts