@remnic/core 9.36.0 → 9.38.1

package/dist/index.js

@@ -109,7 +109,7 @@ import {
   watchForChanges,
   writeManifest,
   writeMeetingEpisodeMemory
-} from "./chunk-SYBHD2IU.js";
+} from "./chunk-QZT2UWL6.js";
 import {
   WEARABLE_SOURCE_PREFIX,
   buildExtractionTurns,
@@ -198,10 +198,10 @@ import "./chunk-PBGWYM3H.js";
 import "./chunk-LTAVSOZW.js";
 import "./chunk-7N4KAIGN.js";
 import "./chunk-V5OCT34X.js";
-import "./chunk-TECVW3JP.js";
-import "./chunk-C5JF6EZ7.js";
 import "./chunk-IJAQCBGV.js";
 import "./chunk-AS7YMSL6.js";
+import "./chunk-TECVW3JP.js";
+import "./chunk-C5JF6EZ7.js";
 import "./chunk-LXOM6IQU.js";
 import "./chunk-VOUOLGIP.js";
 import {
@@ -215,7 +215,7 @@ import "./chunk-I6WYQSX4.js";
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-4EX5WZ4M.js";
-import "./chunk-FT4RF53O.js";
+import "./chunk-EJUEXZHX.js";
 import "./chunk-6DNMUYEE.js";
 import {
   buildTargetedFactRecallSection,
@@ -286,7 +286,7 @@ import {
 import "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-OA6PIPDE.js";
+} from "./chunk-XN3EW6P2.js";
 import "./chunk-4RA3C3EV.js";
 import "./chunk-B6XHIBIB.js";
 import "./chunk-CMQZNEIF.js";
@@ -295,7 +295,7 @@ import "./chunk-2CGLBUW3.js";
 import {
   ModelRegistry
 } from "./chunk-WLZYGLJ4.js";
-import "./chunk-JQSBRLJ6.js";
+import "./chunk-WFTIGIIS.js";
 import "./chunk-WKDFJXW5.js";
 import "./chunk-JUXOTY6J.js";
 import "./chunk-YIAA2X3D.js";
@@ -360,7 +360,7 @@ import {
   runBulkImportCliCommand,
   runMeetingsCliCommand,
   runWearablesCliCommand
-} from "./chunk-WAJPTY5Y.js";
+} from "./chunk-HQYYJRU7.js";
 import "./chunk-MMACM5G2.js";
 import "./chunk-54BGIBCR.js";
 import "./chunk-H4CKS5B2.js";
@@ -567,7 +567,7 @@ import "./chunk-LBJBNWS2.js";
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-ACKB2THH.js";
+} from "./chunk-VU7732DU.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -582,7 +582,7 @@ import "./chunk-7RXCMVFQ.js";
 import "./chunk-MKQBXQKU.js";
 import {
   EngramMcpServer
-} from "./chunk-NN2MCG5N.js";
+} from "./chunk-2YJPCRUM.js";
 import "./chunk-57QKLRBV.js";
 import {
   buildCitationGuidance,
@@ -652,7 +652,7 @@ import {
   validateRequest
 } from "./chunk-3F2LKUMU.js";
 import "./chunk-56BSXSHC.js";
-import "./chunk-XNJIND4I.js";
+import "./chunk-IKKWIPYN.js";
 import "./chunk-5IVLTFOV.js";
 import "./chunk-VCD4PSK2.js";
 import "./chunk-OADWQ5CR.js";

package/dist/local-llm.js

@@ -1,6 +1,6 @@
 import {
   LocalLlmClient
-} from "./chunk-JQSBRLJ6.js";
+} from "./chunk-WFTIGIIS.js";
 import "./chunk-WKDFJXW5.js";
 import "./chunk-JUXOTY6J.js";
 import "./chunk-O75CRYGF.js";

package/dist/orchestrator.js

@@ -4,7 +4,7 @@ import {
   filterRecallCandidates,
   graphPathRelativeToStorage,
   mergeGraphExpandedResults
-} from "./chunk-SYBHD2IU.js";
+} from "./chunk-QZT2UWL6.js";
 import "./chunk-UV72DEZD.js";
 import "./chunk-I74SUMNI.js";
 import "./chunk-ILNPU5W5.js";
@@ -26,10 +26,10 @@ import "./chunk-PBGWYM3H.js";
 import "./chunk-LTAVSOZW.js";
 import "./chunk-7N4KAIGN.js";
 import "./chunk-V5OCT34X.js";
-import "./chunk-TECVW3JP.js";
-import "./chunk-C5JF6EZ7.js";
 import "./chunk-IJAQCBGV.js";
 import "./chunk-AS7YMSL6.js";
+import "./chunk-TECVW3JP.js";
+import "./chunk-C5JF6EZ7.js";
 import "./chunk-LXOM6IQU.js";
 import "./chunk-VOUOLGIP.js";
 import "./chunk-S75M5ZRK.js";
@@ -38,7 +38,7 @@ import "./chunk-KWMXR7XS.js";
 import "./chunk-UHGBNIOS.js";
 import "./chunk-I6WYQSX4.js";
 import "./chunk-4EX5WZ4M.js";
-import "./chunk-FT4RF53O.js";
+import "./chunk-EJUEXZHX.js";
 import "./chunk-6DNMUYEE.js";
 import "./chunk-T67LUYCR.js";
 import "./chunk-QFN4U7AG.js";
@@ -66,14 +66,14 @@ import "./chunk-PHRLJFWZ.js";
 import "./chunk-64NJRYU2.js";
 import "./chunk-K2TDK7GG.js";
 import "./chunk-LTHVM4XN.js";
-import "./chunk-OA6PIPDE.js";
+import "./chunk-XN3EW6P2.js";
 import "./chunk-4RA3C3EV.js";
 import "./chunk-B6XHIBIB.js";
 import "./chunk-CMQZNEIF.js";
 import "./chunk-54V4BZWP.js";
 import "./chunk-2CGLBUW3.js";
 import "./chunk-WLZYGLJ4.js";
-import "./chunk-JQSBRLJ6.js";
+import "./chunk-WFTIGIIS.js";
 import "./chunk-WKDFJXW5.js";
 import "./chunk-JUXOTY6J.js";
 import "./chunk-YIAA2X3D.js";
@@ -95,7 +95,7 @@ import "./chunk-VEWZZM3H.js";
 import "./chunk-Q6IP2ARR.js";
 import "./chunk-6HEM6HTQ.js";
 import "./chunk-3I4FUAVJ.js";
-import "./chunk-WAJPTY5Y.js";
+import "./chunk-HQYYJRU7.js";
 import "./chunk-MMACM5G2.js";
 import "./chunk-54BGIBCR.js";
 import "./chunk-H4CKS5B2.js";
@@ -183,7 +183,7 @@ import "./chunk-OO42R444.js";
 import "./chunk-PIG4WJFQ.js";
 import "./chunk-KFZY2OFH.js";
 import "./chunk-LBJBNWS2.js";
-import "./chunk-ACKB2THH.js";
+import "./chunk-VU7732DU.js";
 import "./chunk-V7IZKJI3.js";
 import "./chunk-SEDEKFYQ.js";
 import "./chunk-RKNJBZ55.js";
@@ -193,7 +193,7 @@ import "./chunk-42NQ7AVG.js";
 import "./chunk-TMSXWOBZ.js";
 import "./chunk-7RXCMVFQ.js";
 import "./chunk-MKQBXQKU.js";
-import "./chunk-NN2MCG5N.js";
+import "./chunk-2YJPCRUM.js";
 import "./chunk-57QKLRBV.js";
 import "./chunk-D24OXEPB.js";
 import "./chunk-GORHSN5C.js";
@@ -207,7 +207,7 @@ import "./chunk-CEN6DW6X.js";
 import "./chunk-T4WDJPEZ.js";
 import "./chunk-3F2LKUMU.js";
 import "./chunk-56BSXSHC.js";
-import "./chunk-XNJIND4I.js";
+import "./chunk-IKKWIPYN.js";
 import "./chunk-5IVLTFOV.js";
 import "./chunk-VCD4PSK2.js";
 import "./chunk-OADWQ5CR.js";

package/dist/summarizer.js

@@ -1,9 +1,9 @@
 import {
   HourlySummarizer
-} from "./chunk-FT4RF53O.js";
+} from "./chunk-EJUEXZHX.js";
 import "./chunk-6DNMUYEE.js";
 import "./chunk-WLZYGLJ4.js";
-import "./chunk-JQSBRLJ6.js";
+import "./chunk-WFTIGIIS.js";
 import "./chunk-WKDFJXW5.js";
 import "./chunk-JUXOTY6J.js";
 import "./chunk-S4DDLTPX.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.36.0",
+  "version": "9.38.1",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3086,7 +3086,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.36.0"
+    "@remnic/coding-graph": "^9.38.1"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-mcp-output-schemas.ts

@@ -16,8 +16,16 @@ const T_NULLABLE_OBJECT = { type: ["object", "null"] } as const;
 const T_NULLABLE_STRING = { type: ["string", "null"] } as const;
 
 /** Build a JSON Schema object type with the given properties. */
-function objectSchema(properties: Record<string, Readonly<Record<string, unknown>>>): Record<string, unknown> {
-  return { type: "object", properties, additionalProperties: true };
+function objectSchema(
+  properties: Record<string, Readonly<Record<string, unknown>>>,
+  required?: readonly string[],
+): Record<string, unknown> {
+  return {
+    type: "object",
+    properties,
+    ...(required && required.length > 0 ? { required } : {}),
+    additionalProperties: true,
+  };
 }
 
 /**
@@ -53,10 +61,10 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     sources: T_ARRAY,
     connectorsInstalled: T_ARRAY,
   }),
-  wearables_sync: objectSchema({ summaries: T_ARRAY }),
-  transcript_day: objectSchema({ transcripts: T_ARRAY }),
-  transcript_search: objectSchema({ results: T_ARRAY }),
-  transcript_memories: objectSchema({ memories: T_ARRAY }),
+  wearables_sync: objectSchema({ summaries: T_ARRAY }, ["summaries"]),
+  transcript_day: objectSchema({ transcripts: T_ARRAY }, ["transcripts"]),
+  transcript_search: objectSchema({ results: T_ARRAY }, ["results"]),
+  transcript_memories: objectSchema({ memories: T_ARRAY }, ["memories"]),
   meetings_list: objectSchema({ enabled: T_BOOLEAN, days: T_ARRAY }),
   meetings_get: objectSchema({ enabled: T_BOOLEAN, found: T_BOOLEAN, id: T_STRING, record: T_NULLABLE_STRING }),
   meetings_build: objectSchema({

package/src/access-mcp.ts

@@ -2445,13 +2445,13 @@ export class EngramMcpServer {
         if (isReadOnlyToolName(name)) {
           throwMcpAbort(options?.abortSignal, "MCP request aborted before response");
         }
-        const structuredContent = result ?? {};
+        const structuredContent = result;
         return {
           jsonrpc: "2.0",
           id,
           result: {
-            content: [{ type: "text", text: JSON.stringify(structuredContent, null, 2) }],
-            structuredContent,
+            content: [{ type: "text", text: JSON.stringify(result ?? null, null, 2) }],
+            ...(structuredContent == null ? {} : { structuredContent }),
             isError: false,
           },
         };

package/src/local-llm-headers-timeout.test.ts

@@ -68,6 +68,11 @@ function primeClient(client: LocalLlmClient): void {
   internals.detectedType = "generic";
 }
 
+function clientIsAvailable(client: LocalLlmClient): boolean {
+  const internals = client as unknown as { isAvailable: boolean };
+  return internals.isAvailable;
+}
+
 /** Test seam: the pool is private, but its budget is what we assert on. */
 function dispatcherOf(client: LocalLlmClient): Agent {
   const seam = client as unknown as {
@@ -122,6 +127,63 @@ async function startSlowHeaderServer(delayMs: number): Promise<{
   };
 }
 
+async function startTricklingBodyServer(chunkIntervalMs: number, status = 200): Promise<{
+  url: string;
+  requestBodies: string[];
+  close: () => Promise<void>;
+}> {
+  const pending = new Set<NodeJS.Timeout>();
+  const requestBodies: string[] = [];
+  const payload = JSON.stringify({
+    choices: [{ message: { content: "late completion" } }],
+    usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+  });
+  const chunkSize = Math.ceil(payload.length / 16);
+  const chunks = Array.from(
+    { length: 16 },
+    (_, index) => payload.slice(index * chunkSize, (index + 1) * chunkSize),
+  ).filter((chunk) => chunk.length > 0);
+  const server = http.createServer((req, res) => {
+    let requestBody = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk: string) => {
+      requestBody += chunk;
+    });
+    req.on("end", () => {
+      requestBodies.push(requestBody);
+      res.writeHead(status, { "content-type": "application/json" });
+      res.flushHeaders();
+      let index = 0;
+      const interval = setInterval(() => {
+        const chunk = chunks[index];
+        index += 1;
+        if (chunk !== undefined) res.write(chunk);
+        if (index >= chunks.length) {
+          clearInterval(interval);
+          pending.delete(interval);
+          res.end();
+        }
+      }, chunkIntervalMs);
+      pending.add(interval);
+      res.once("close", () => {
+        clearInterval(interval);
+        pending.delete(interval);
+      });
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address() as AddressInfo;
+  return {
+    url: `http://127.0.0.1:${port}/v1`,
+    requestBodies,
+    close: async () => {
+      for (const interval of pending) clearInterval(interval);
+      pending.clear();
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    },
+  };
+}
+
 test("chat completion passes an undici dispatcher to fetch", async () => {
   const original = globalThis.fetch;
   let seenDispatcher: unknown;
@@ -244,6 +306,138 @@ test("a completion whose headers lag the request still succeeds", async () => {
   }
 });
 
+test("the request budget covers a trickling response body", async () => {
+  const timeoutMs = 250;
+  const server = await startTricklingBodyServer(75);
+  const client = new LocalLlmClient(
+    createConfig({ localLlmUrl: server.url, localLlmTimeoutMs: timeoutMs }),
+  );
+  try {
+    primeClient(client);
+    const startedAt = Date.now();
+    const result = await client.chatCompletion([
+      { role: "user", content: "extract facts" },
+    ]);
+    const elapsedMs = Date.now() - startedAt;
+
+    assert.equal(result, null);
+    assert.ok(
+      elapsedMs < 800,
+      `response body must abort near the ${timeoutMs}ms request budget; elapsed ${elapsedMs}ms`,
+    );
+    const requestBody: unknown = JSON.parse(server.requestBodies[0] ?? "{}");
+    assert.ok(requestBody && typeof requestBody === "object" && "stream" in requestBody);
+    assert.equal(requestBody.stream, false);
+  } finally {
+    await dispatcherOf(client).close();
+    await server.close();
+  }
+});
+
+test("caller abort during body consumption remains cancellation for an arbitrary reason", async () => {
+  const original = globalThis.fetch;
+  const caller = new AbortController();
+  let calls = 0;
+  globalThis.fetch = (async (_url: string, init?: RequestInit) => {
+    calls += 1;
+    const signal = init?.signal;
+    assert.ok(signal);
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        signal.addEventListener("abort", () => controller.error(signal.reason), { once: true });
+      },
+    });
+    queueMicrotask(() => caller.abort(new Error("caller cancelled")));
+    return new Response(body, {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  }) as typeof fetch;
+
+  const client = new LocalLlmClient(createConfig({ localLlmRetry5xxCount: 2 }));
+  try {
+    primeClient(client);
+    const result = await client.chatCompletion(
+      [{ role: "user", content: "extract facts" }],
+      { signal: caller.signal },
+    );
+    assert.equal(result, null);
+    assert.equal(calls, 1);
+    assert.equal(clientIsAvailable(client), true);
+  } finally {
+    globalThis.fetch = original;
+    await dispatcherOf(client).close();
+  }
+});
+
+test("a timed-out 400 body is accounted once and enters cooldown", async () => {
+  const server = await startTricklingBodyServer(75, 400);
+  const client = new LocalLlmClient(
+    createConfig({
+      localLlmUrl: server.url,
+      localLlmTimeoutMs: 250,
+      localLlmRetry5xxCount: 2,
+      localLlm400TripThreshold: 1,
+    }),
+  );
+  try {
+    primeClient(client);
+    assert.equal(
+      await client.chatCompletion([{ role: "user", content: "extract facts" }]),
+      null,
+    );
+    assert.equal(server.requestBodies.length, 1);
+    assert.equal(
+      await client.chatCompletion([{ role: "user", content: "extract facts again" }]),
+      null,
+    );
+    assert.equal(server.requestBodies.length, 1, "cooldown must stop a second request");
+  } finally {
+    await dispatcherOf(client).close();
+    await server.close();
+  }
+});
+
+test("a truncated 503 body retains the configured retry", async () => {
+  const original = globalThis.fetch;
+  const encoder = new TextEncoder();
+  let calls = 0;
+  globalThis.fetch = (async () => {
+    calls += 1;
+    if (calls === 1) {
+      const body = new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(encoder.encode('{"error":'));
+          controller.error(new TypeError("terminated"));
+        },
+      });
+      return new Response(body, {
+        status: 503,
+        headers: { "content-type": "application/json" },
+      });
+    }
+    return new Response(
+      JSON.stringify({ choices: [{ message: { content: "retry succeeded" } }] }),
+      { status: 200, headers: { "content-type": "application/json" } },
+    );
+  }) as typeof fetch;
+
+  const client = new LocalLlmClient(
+    createConfig({ localLlmRetry5xxCount: 1, localLlmRetryBackoffMs: 1 }),
+  );
+  try {
+    primeClient(client);
+    const result = await client.chatCompletion([
+      { role: "user", content: "extract facts" },
+    ]);
+    assert.equal(result?.content, "retry succeeded");
+    assert.equal(calls, 2);
+  } finally {
+    globalThis.fetch = original;
+    await dispatcherOf(client).close();
+  }
+});
+
 test("a process-wide custom dispatcher is left in place", async () => {
   // A deployment may reach the local endpoint only through a ProxyAgent (or
   // another custom connect/TLS/DNS transport) installed with

package/src/local-llm.ts

@@ -962,6 +962,7 @@ export class LocalLlmClient {
         temperature: options.temperature ?? 0.7,
         // Use max_tokens consistent with cloud models
         max_tokens: options.maxTokens ?? 4096,
+        stream: false,
       };
 
       // Skip response_format for local LLMs - they don't support json_object type
@@ -1034,9 +1035,11 @@ export class LocalLlmClient {
           ? Math.min(this.config.localLlmTimeoutMs, options.timeoutMs)
           : this.config.localLlmTimeoutMs;
       const maxAttempts = 1 + Math.max(0, this.config.localLlmRetry5xxCount);
-      let response: Response | null = null;
+      let response: Response | null = null, responseBody = "";
       let lastAbortError: Error | null = null;
       for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        response = null;
+        responseBody = "";
         const attemptAbort = new AbortController();
         const onCallerAbort = (): void => {
           attemptAbort.abort(options.signal?.reason);
@@ -1059,18 +1062,28 @@ export class LocalLlmClient {
             signal: attemptAbort.signal,
             budgetMs: this.config.localLlmTimeoutMs,
           });
+          responseBody = await response.text();
         } catch (err) {
-          if (!isAbortError(err)) throw err;
-          lastAbortError = err instanceof Error ? err : new Error(String(err));
-          if (options.signal?.aborted || attempt >= maxAttempts) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          if (options.signal?.aborted) {
+            response = null;
+            lastAbortError = error;
             break;
           }
-          const backoffMs = this.config.localLlmRetryBackoffMs * attempt;
-          log.warn(
-            `local LLM request aborted: op=${operation} attempt=${attempt}/${maxAttempts} timeoutMs=${effectiveTimeoutMs} model=${this.config.localLlmModel}; retrying after ${backoffMs}ms`,
-          );
-          if (!(await waitForRetryBackoff(backoffMs, options.signal))) return null;
-          continue;
+          if (response && !response.ok) {
+            log.debug(`local LLM failed to read ${response.status} response body: ${error.message}`);
+          } else {
+            response = null;
+            if (!isAbortError(err)) throw err;
+            lastAbortError = error;
+            if (attempt >= maxAttempts) break;
+            const backoffMs = this.config.localLlmRetryBackoffMs * attempt;
+            log.warn(
+              `local LLM request aborted: op=${operation} attempt=${attempt}/${maxAttempts} timeoutMs=${effectiveTimeoutMs} model=${this.config.localLlmModel}; retrying after ${backoffMs}ms`,
+            );
+            if (!(await waitForRetryBackoff(backoffMs, options.signal))) return null;
+            continue;
+          }
         } finally {
           clearTimeout(attemptTimeout);
           options.signal?.removeEventListener("abort", onCallerAbort);
@@ -1078,20 +1091,15 @@ export class LocalLlmClient {
 
         if (response.ok) break;
         if (response.status >= 500 && attempt < maxAttempts) {
-          try {
-            const errorText = await response.clone().text();
-            const nonRecoverableReason =
-              extractNonRecoverableBackendReasonFromErrorText(errorText);
-            if (nonRecoverableReason) {
-              this.markBackendUnavailable(
-                nonRecoverableReason,
-                this.config.localLlm400CooldownMs,
-              );
-              this.consecutive400s = 0;
-              return null;
-            }
-          } catch (e) {
-            log.debug(`local LLM failed to inspect retryable error body: ${e}`);
+          const nonRecoverableReason =
+            extractNonRecoverableBackendReasonFromErrorText(responseBody);
+          if (nonRecoverableReason) {
+            this.markBackendUnavailable(
+              nonRecoverableReason,
+              this.config.localLlm400CooldownMs,
+            );
+            this.consecutive400s = 0;
+            return null;
           }
         }
         if (response.status < 500 || attempt >= maxAttempts) break;
@@ -1120,19 +1128,11 @@ export class LocalLlmClient {
 
       if (!response.ok) {
         let reason = "";
-        let errorText = "";
         try {
-          errorText = await response.text();
-          // Try to extract a stable error message without logging content.
-          try {
-            const parsed = JSON.parse(errorText) as { error?: { message?: string } };
-            reason = parsed?.error?.message ? ` — ${parsed.error.message}` : "";
-          } catch {
-            // Keep a short preview in debug only.
-            log.debug(`local LLM error body: ${errorText.slice(0, 500)}`);
-          }
-        } catch (e) {
-          log.debug(`local LLM failed to read error body: ${e}`);
+          const parsed = JSON.parse(responseBody) as { error?: { message?: string } };
+          reason = parsed?.error?.message ? ` — ${parsed.error.message}` : "";
+        } catch {
+          log.debug(`local LLM error body: ${responseBody.slice(0, 500)}`);
         }
         log.warn(
           `local LLM request failed: ${response.status} ${response.statusText}${reason} ` +
@@ -1140,7 +1140,7 @@ export class LocalLlmClient {
         );
         const nonRecoverableReason =
           extractNonRecoverableBackendReason(reason) ??
-          extractNonRecoverableBackendReasonFromErrorText(errorText);
+          extractNonRecoverableBackendReasonFromErrorText(responseBody);
         if (nonRecoverableReason) {
           this.markBackendUnavailable(
             nonRecoverableReason,
@@ -1166,7 +1166,7 @@ export class LocalLlmClient {
       }
       this.consecutive400s = 0;
 
-      const data = (await response.json()) as {
+      const data = JSON.parse(responseBody) as {
         choices?: Array<{
           message?: { content?: string; reasoning_content?: string };
         }>;