@anuma/sdk 5.0.2 → 5.0.4

package/dist/client/index.d.mts

@@ -1137,7 +1137,7 @@ type LlmapiResponseRequest = {
      */
     tools?: Array<LlmapiResponseTool>;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -8562,7 +8562,7 @@ type PostApiV1ResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1ResponsesResponse = PostApiV1ResponsesResponses[keyof PostApiV1ResponsesResponses];
 type GetApiV1SharesData = {
@@ -9563,7 +9563,7 @@ type PostApiV1UtilityResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1UtilityResponsesResponse = PostApiV1UtilityResponsesResponses[keyof PostApiV1UtilityResponsesResponses];
 type GetApiV1WalletsBindingData = {
@@ -11237,6 +11237,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;

package/dist/client/index.d.ts

@@ -1137,7 +1137,7 @@ type LlmapiResponseRequest = {
      */
     tools?: Array<LlmapiResponseTool>;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -8562,7 +8562,7 @@ type PostApiV1ResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1ResponsesResponse = PostApiV1ResponsesResponses[keyof PostApiV1ResponsesResponses];
 type GetApiV1SharesData = {
@@ -9563,7 +9563,7 @@ type PostApiV1UtilityResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1UtilityResponsesResponse = PostApiV1UtilityResponsesResponses[keyof PostApiV1UtilityResponsesResponses];
 type GetApiV1WalletsBindingData = {
@@ -11237,6 +11237,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;

package/dist/expo/index.cjs

@@ -10784,6 +10784,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -10819,6 +10829,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -11087,7 +11099,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -12106,6 +12128,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }
@@ -17281,7 +17306,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -17342,7 +17374,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -17365,9 +17397,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;

package/dist/expo/index.d.mts

@@ -407,7 +407,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1234,6 +1234,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2428,6 +2452,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /**
  * Terminal state of the LAST model response in the turn, normalized to the
@@ -2435,13 +2474,14 @@ type StepFinishEvent = {
  * specific values). `undefined` when the stream carried no finish reason at all.
  *
  * Exposed because neither response shape reliably carries it out to a caller.
- * The Responses API shape has no field for it — `LlmapiResponseResponse` declares
- * neither `status` nor `incomplete_details` — so `buildFinalResponse` cannot
- * surface truncation there even though the loop detected it (`responses.ts`
- * normalizes it onto the accumulator). Completions does expose
- * `choices[0].finish_reason`, but omits `tool_calls` entirely when there are
- * none, so a caller sniffing the response cannot tell "no tool calls" from
- * "field absent".
+ * The Responses shape now carries `status` / `incomplete_details` — added in
+ * `clientCompat` and emitted by `buildFinalResponse` — but only in the
+ * Responses vocabulary, so a caller reading it has to translate
+ * `incomplete_details.reason === "max_output_tokens"` itself. Completions
+ * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
+ * there are none, so a caller sniffing the response cannot tell "no tool calls"
+ * from "field absent". This field answers both questions in one vocabulary,
+ * for either transport.
  *
  * The loop already knows both, unambiguously and identically for either API.
  * Reporting them here means callers and test harnesses stop reverse-engineering

package/dist/expo/index.d.ts

@@ -407,7 +407,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1234,6 +1234,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2428,6 +2452,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /**
  * Terminal state of the LAST model response in the turn, normalized to the
@@ -2435,13 +2474,14 @@ type StepFinishEvent = {
  * specific values). `undefined` when the stream carried no finish reason at all.
  *
  * Exposed because neither response shape reliably carries it out to a caller.
- * The Responses API shape has no field for it — `LlmapiResponseResponse` declares
- * neither `status` nor `incomplete_details` — so `buildFinalResponse` cannot
- * surface truncation there even though the loop detected it (`responses.ts`
- * normalizes it onto the accumulator). Completions does expose
- * `choices[0].finish_reason`, but omits `tool_calls` entirely when there are
- * none, so a caller sniffing the response cannot tell "no tool calls" from
- * "field absent".
+ * The Responses shape now carries `status` / `incomplete_details` — added in
+ * `clientCompat` and emitted by `buildFinalResponse` — but only in the
+ * Responses vocabulary, so a caller reading it has to translate
+ * `incomplete_details.reason === "max_output_tokens"` itself. Completions
+ * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
+ * there are none, so a caller sniffing the response cannot tell "no tool calls"
+ * from "field absent". This field answers both questions in one vocabulary,
+ * for either transport.
  *
  * The loop already knows both, unambiguously and identically for either API.
  * Reporting them here means callers and test harnesses stop reverse-engineering

package/dist/expo/index.mjs

@@ -1823,6 +1823,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -1858,6 +1868,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -2126,7 +2138,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -3145,6 +3167,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }
@@ -8237,7 +8262,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -8298,7 +8330,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -8321,9 +8353,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;

package/dist/index.d.mts

@@ -990,7 +990,7 @@ type LlmapiResponseRequest = {
      */
     tools?: Array<LlmapiResponseTool>;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -5840,7 +5840,7 @@ type PostApiV1ResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1ResponsesResponse = PostApiV1ResponsesResponses[keyof PostApiV1ResponsesResponses];
 type PostApiV1SubscriptionsCancelData = {
@@ -7166,6 +7166,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;

package/dist/index.d.ts

@@ -990,7 +990,7 @@ type LlmapiResponseRequest = {
      */
     tools?: Array<LlmapiResponseTool>;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -5840,7 +5840,7 @@ type PostApiV1ResponsesResponses = {
     /**
      * OK
      */
-    200: LlmapiResponseResponse | string;
+    200: LlmapiResponseResponse$1 | string;
 };
 type PostApiV1ResponsesResponse = PostApiV1ResponsesResponses[keyof PostApiV1ResponsesResponses];
 type PostApiV1SubscriptionsCancelData = {
@@ -7166,6 +7166,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;

package/dist/react/index.cjs

@@ -11144,6 +11144,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -11179,6 +11189,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -11447,7 +11459,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -12466,6 +12488,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }
@@ -18580,7 +18605,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -18641,7 +18673,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -18664,9 +18696,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;

package/dist/react/index.d.mts

@@ -703,7 +703,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1669,6 +1669,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2390,6 +2414,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /** Capability header: tells the portal this client can resume a detached stream. Pinned with zeta-chain/ai-portal#1139. */
 declare const STREAM_RESUMABLE_HEADER = "X-Stream-Resumable";

package/dist/react/index.d.ts

@@ -703,7 +703,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1669,6 +1669,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2390,6 +2414,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /** Capability header: tells the portal this client can resume a detached stream. Pinned with zeta-chain/ai-portal#1139. */
 declare const STREAM_RESUMABLE_HEADER = "X-Stream-Resumable";

package/dist/react/index.mjs

@@ -1700,6 +1700,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -1735,6 +1745,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -2003,7 +2015,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -3022,6 +3044,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }
@@ -9054,7 +9079,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -9115,7 +9147,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -9138,9 +9170,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;

package/dist/server/index.cjs

@@ -30351,7 +30351,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -30412,7 +30419,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -30435,9 +30442,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;
@@ -34383,6 +34394,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -34418,6 +34439,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -34686,7 +34709,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -35705,6 +35738,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }

package/dist/server/index.d.mts

@@ -830,7 +830,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1613,6 +1613,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2231,6 +2255,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /**
  * Options for `runToolLoop`.
@@ -2444,13 +2483,14 @@ type RunToolLoopOptions = {
  * specific values). `undefined` when the stream carried no finish reason at all.
  *
  * Exposed because neither response shape reliably carries it out to a caller.
- * The Responses API shape has no field for it — `LlmapiResponseResponse` declares
- * neither `status` nor `incomplete_details` — so `buildFinalResponse` cannot
- * surface truncation there even though the loop detected it (`responses.ts`
- * normalizes it onto the accumulator). Completions does expose
- * `choices[0].finish_reason`, but omits `tool_calls` entirely when there are
- * none, so a caller sniffing the response cannot tell "no tool calls" from
- * "field absent".
+ * The Responses shape now carries `status` / `incomplete_details` — added in
+ * `clientCompat` and emitted by `buildFinalResponse` — but only in the
+ * Responses vocabulary, so a caller reading it has to translate
+ * `incomplete_details.reason === "max_output_tokens"` itself. Completions
+ * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
+ * there are none, so a caller sniffing the response cannot tell "no tool calls"
+ * from "field absent". This field answers both questions in one vocabulary,
+ * for either transport.
  *
  * The loop already knows both, unambiguously and identically for either API.
  * Reporting them here means callers and test harnesses stop reverse-engineering

package/dist/server/index.d.ts

@@ -830,7 +830,7 @@ type LlmapiResponseReasoning = {
      */
     summary?: string;
 };
-type LlmapiResponseResponse = {
+type LlmapiResponseResponse$1 = {
     /**
      * ClientInjectedTools are tool names the client provided in the original request.
      */
@@ -1613,6 +1613,30 @@ type LlmapiChatCompletionUsage = OpenaiCompletionUsage & {
  * strategies/completions.ts `buildFinalResponse`. See that TODO for the full
  * deprecation plan.
  */
+/**
+ * Add the Responses API's terminal-state fields, which the portal's generated
+ * schema does not declare.
+ *
+ * Without them the two transports are asymmetric: a completions consumer reads
+ * `choices[0].finish_reason` and can see a turn cut off at the output ceiling,
+ * while a Responses consumer has no field to read at all — the truncation the
+ * SDK *did* detect (see the normalization in `strategies/responses.ts`) died at
+ * the stream boundary. `runToolLoop` works around this with `terminalState` on
+ * its own result, but a caller holding only a response object cannot (#805).
+ *
+ * These are standard OpenAI Responses fields, so this widens the type toward
+ * the wire rather than inventing shape: they are optional because a
+ * non-streaming direct call returns only what the portal serializes today.
+ * Drop the override once the portal declares them upstream.
+ */
+type LlmapiResponseResponse = LlmapiResponseResponse$1 & {
+    /** `"completed"` | `"incomplete"` — the turn's own status, not an output item's. */
+    status?: string;
+    /** Present when `status` is `"incomplete"`; `"max_output_tokens"` is a truncation. */
+    incomplete_details?: {
+        reason?: string;
+    };
+};
 type LlmapiChatCompletionResponse = Omit<LlmapiChatCompletionResponse$1, "usage"> & {
     usage?: LlmapiChatCompletionUsage;
     inference_id?: string;
@@ -2231,6 +2255,21 @@ type StepFinishEvent = {
         inputTokens?: number;
         outputTokens?: number;
     };
+    /**
+     * The round's own finish reason, as the provider sent it — `"length"` means
+     * this round hit the output ceiling.
+     *
+     * Per-round, not per-turn: a round can truncate and the loop still recover on
+     * the next one, which is why the loop does not treat it as an error on its
+     * own (see the truncation guard below). Without it a consumer watching steps
+     * cannot tell a round that said everything it meant to from one that was cut
+     * off mid-argument — they differ only in this field (#805).
+     *
+     * Absent when the provider sent no finish reason. Note that no step event
+     * fires for the round that *ends* a turn, so use {@link RunTerminalState} on
+     * the result for the final round.
+     */
+    finishReason?: string;
 };
 /**
  * Options for `runToolLoop`.
@@ -2444,13 +2483,14 @@ type RunToolLoopOptions = {
  * specific values). `undefined` when the stream carried no finish reason at all.
  *
  * Exposed because neither response shape reliably carries it out to a caller.
- * The Responses API shape has no field for it — `LlmapiResponseResponse` declares
- * neither `status` nor `incomplete_details` — so `buildFinalResponse` cannot
- * surface truncation there even though the loop detected it (`responses.ts`
- * normalizes it onto the accumulator). Completions does expose
- * `choices[0].finish_reason`, but omits `tool_calls` entirely when there are
- * none, so a caller sniffing the response cannot tell "no tool calls" from
- * "field absent".
+ * The Responses shape now carries `status` / `incomplete_details` — added in
+ * `clientCompat` and emitted by `buildFinalResponse` — but only in the
+ * Responses vocabulary, so a caller reading it has to translate
+ * `incomplete_details.reason === "max_output_tokens"` itself. Completions
+ * exposes `choices[0].finish_reason`, but omits `tool_calls` entirely when
+ * there are none, so a caller sniffing the response cannot tell "no tool calls"
+ * from "field absent". This field answers both questions in one vocabulary,
+ * for either transport.
  *
  * The loop already knows both, unambiguously and identically for either API.
  * Reporting them here means callers and test harnesses stop reverse-engineering

package/dist/server/index.mjs

@@ -7061,7 +7061,14 @@ async function synthesizeProfile(ctx, options = {}) {
       observationTrends
     };
   }
-  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const staleKeys = await computeStaleFacetKeys(
+    ctx,
+    memories,
+    facets,
+    previous,
+    watermark,
+    options.reviewedMemoryIds
+  );
   const settled = await Promise.allSettled(
     facets.map(async (facet) => {
       const prior = previous?.sections.find((s) => s.key === facet.key);
@@ -7122,7 +7129,7 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
@@ -7145,9 +7152,13 @@ async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark)
     if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
   }
   const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
-  const toAttribute = changed.filter(
+  let toAttribute = changed.filter(
     (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
   );
+  if (reviewedMemoryIds !== void 0) {
+    const allowed = new Set(reviewedMemoryIds);
+    toAttribute = toAttribute.filter((m) => allowed.has(m.uniqueId));
+  }
   if (toAttribute.length > 0) {
     const attributed = await attributeFacts(ctx, toAttribute, facets);
     if (attributed === null) return allKeys;
@@ -11054,6 +11065,16 @@ var ResponsesStrategy = class {
         }));
         mergeToolCallEventsIntoAccumulator(accumulator, toolCallEvents);
       }
+      const fbStatus = typeof resp.status === "string" ? resp.status : void 0;
+      const fbIncompleteReason = resp.incomplete_details?.reason;
+      const fbFinishReason = typeof resp.finish_reason === "string" ? resp.finish_reason : void 0;
+      if (fbStatus !== void 0) accumulator.responseStatus = fbStatus;
+      if (fbIncompleteReason !== void 0) accumulator.incompleteReason = fbIncompleteReason;
+      if (fbFinishReason !== void 0) {
+        accumulator.finishReason = fbFinishReason;
+      } else if (fbStatus === "incomplete" && fbIncompleteReason === "max_output_tokens") {
+        accumulator.finishReason = "length";
+      }
       return result;
     }
     if (typedChunk.type === "response.created" && typedChunk.response) {
@@ -11089,6 +11110,8 @@ var ResponsesStrategy = class {
       if (looksIncomplete && resp?.incomplete_details?.reason === "max_output_tokens") {
         accumulator.finishReason = "length";
       }
+      accumulator.responseStatus = looksIncomplete ? "incomplete" : resp?.status;
+      accumulator.incompleteReason = resp?.incomplete_details?.reason;
       if (typedChunk.response?.tools_checksum && !accumulator.toolsChecksum) {
         accumulator.toolsChecksum = typedChunk.response.tools_checksum;
       }
@@ -11357,7 +11380,17 @@ var ResponsesStrategy = class {
       output,
       usage: Object.keys(accumulator.usage).length > 0 ? accumulator.usage : void 0,
       tools_checksum: accumulator.toolsChecksum,
-      tool_call_events: accumulator.toolCallEvents
+      tool_call_events: accumulator.toolCallEvents,
+      // Response-level terminal state (#805). Note the individual output items
+      // above hardcode `status: "completed"` — that is the item's own status
+      // and says nothing about the turn. Only these two fields can tell a
+      // caller the turn was cut off, and until now neither survived the stream.
+      // Omitted rather than emitted as `undefined` so a clean turn's response
+      // shape is unchanged.
+      ...accumulator.responseStatus !== void 0 && { status: accumulator.responseStatus },
+      ...accumulator.incompleteReason !== void 0 && {
+        incomplete_details: { reason: accumulator.incompleteReason }
+      }
     };
   }
 };
@@ -12376,6 +12409,9 @@ Executing tool: ${toolInfo}
           usage: {
             inputTokens: currentAccumulator.usage.prompt_tokens,
             outputTokens: currentAccumulator.usage.completion_tokens
+          },
+          ...currentAccumulator.finishReason !== void 0 && {
+            finishReason: currentAccumulator.finishReason
           }
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "5.0.2",
+  "version": "5.0.4",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",