@shpitdev/convex-cliproxy-observability 0.3.6 → 0.3.8

package/src/capture/content-health.ts

@@ -7,6 +7,8 @@ export const contentHealthValidator = v.object({
   lostBytes: v.number(),
   unconfirmedBytes: v.number(),
   unknownLosses: v.number(),
+  /** Native 0.2.5: enrolled calls that could not start a scope. Optional for older senders. */
+  missedCalls: v.optional(v.number()),
   streamCallbacks: v.number(),
   incompleteCalls: v.number(),
   capacityRejections: v.number(),
@@ -18,12 +20,13 @@ export function validContentHealth(value: unknown): boolean {
   if (value === undefined) return true;
   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
   const counters = value as Record<string, unknown>;
+  const fields = Object.keys(contentHealthValidator.fields);
   return (
-    Object.keys(counters).length === Object.keys(contentHealthValidator.fields).length &&
-    Object.keys(contentHealthValidator.fields).every((key) => {
-      const n = counters[key];
-      return typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
-    }) &&
+    Object.keys(counters).every((key) => fields.includes(key)) &&
+    fields.every((key) => key === "missedCalls" || key in counters) &&
+    Object.values(counters).every(
+      (n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0,
+    ) &&
     (counters.retainedChargedBytes as number) <= (counters.peakChargedBytes as number)
   );
 }

package/src/capture/index.ts

@@ -2,6 +2,8 @@ import { expandStockHookBlock } from "../protocols/stock-block.js";
 import type { ExactCorrelation } from "../model-call/index.js";
 export const MAX_ENVELOPE_BYTES = 2 * 1024 * 1024;
 export const MAX_CONTENT_BYTES = 1024 * 1024;
+/** One split body spans at most the producer's 256 shared data-record slots. */
+export const MAX_BODY_PARTS = 256;
 const id = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/;
 const routes = new Set([
   "GET /v1/models",
@@ -10,6 +12,20 @@ const routes = new Set([
   "POST /v1/responses",
   "POST /v1/chat/completions",
 ]);
+/**
+ * Native 0.2.5 splits a body larger than `MAX_CONTENT_BYTES` into exact ordered
+ * parts with consecutive sequences. Every part but the last holds exactly
+ * `MAX_CONTENT_BYTES`; `offset` is `index * MAX_CONTENT_BYTES`. Concatenate in
+ * index order and verify `totalBytes`/`totalSha256` (see `/protocols`
+ * `BodyPartAssembler`). A split stream callback is one stock callback.
+ */
+export type BodyPartV1 = {
+  index: number;
+  count: number;
+  offset: number;
+  totalBytes: number;
+  totalSha256: string;
+};
 export type CaptureObservationV1 = {
   schemaVersion: 1;
   pluginVersion: string;
@@ -49,6 +65,7 @@ export type CaptureObservationV1 = {
   bodyFraming?:
     "stock_json_chunk" | "stock_sse_candidate" | "stock_hook_chunk" | "stock_hook_block";
   stockHookChunkLengths?: number[];
+  bodyPart?: BodyPartV1;
   lostContentBytes?: number;
   captureIncomplete?: boolean;
   contentSha256: string;
@@ -141,6 +158,7 @@ export async function validateObservation(
     "correlationConflicts",
     "stockChunkIndex",
     "stockHookChunkLengths",
+    "bodyPart",
     "lostContentBytes",
     "captureIncomplete",
     "body",
@@ -300,6 +318,7 @@ export async function validateObservation(
   )
     throw new Error("invalid body framing");
   const body = decodeBody(o);
+  if (o.bodyPart !== undefined) validateBodyPart(o, body);
   if (o.bodyFraming === "stock_hook_block") {
     if (o.capturePolicy !== "hook-content-block-v1" || o.kind !== "stream_chunk")
       throw new Error("stock block policy required");
@@ -354,6 +373,53 @@ export async function validateObservation(
   };
 }
 
+const partKinds = new Set(["request", "request_after_auth", "response", "stream_chunk"]);
+function validateBodyPart(o: CaptureObservationV1, body: Uint8Array) {
+  const part: unknown = o.bodyPart;
+  const keys = ["index", "count", "offset", "totalBytes", "totalSha256"];
+  if (
+    !part ||
+    typeof part !== "object" ||
+    Array.isArray(part) ||
+    Object.keys(part).length !== keys.length ||
+    !keys.every((key) => key in part)
+  )
+    throw new Error("invalid body part");
+  const { index, count, offset, totalBytes, totalSha256 } = part as BodyPartV1;
+  if (
+    o.capturePolicy !== "hook-content-block-v1" ||
+    !partKinds.has(o.kind) ||
+    ![index, count, offset, totalBytes].every(Number.isSafeInteger) ||
+    count < 2 ||
+    count > MAX_BODY_PARTS ||
+    index < 0 ||
+    index >= count ||
+    offset !== index * MAX_CONTENT_BYTES ||
+    totalBytes <= (count - 1) * MAX_CONTENT_BYTES ||
+    totalBytes > count * MAX_CONTENT_BYTES ||
+    body.byteLength !== Math.min(MAX_CONTENT_BYTES, totalBytes - offset) ||
+    typeof totalSha256 !== "string" ||
+    !/^[a-f0-9]{64}$/.test(totalSha256)
+  )
+    throw new Error("invalid body part");
+}
+type PartPosition = Pick<CaptureObservationV1, "kind" | "sequence" | "bodyPart">;
+/** True when `next` is the part that must follow `previous` in one split body. */
+export function continuesBodyPart(previous: PartPosition, next: PartPosition) {
+  const a = previous.bodyPart;
+  const b = next.bodyPart;
+  return (
+    !!a &&
+    !!b &&
+    next.kind === previous.kind &&
+    next.sequence === previous.sequence + 1 &&
+    b.index === a.index + 1 &&
+    b.count === a.count &&
+    b.totalBytes === a.totalBytes &&
+    b.totalSha256 === a.totalSha256
+  );
+}
+
 /** One immutable NDJSON segment batches observations: no per-token Convex writes. */
 export type CaptureSegmentV1 = {
   schemaVersion: 1;
@@ -424,6 +490,14 @@ export async function validateSegment(
     )
   )
     throw new Error("inconsistent segment lifecycle");
+  // Parts of one split body are consecutive; neighbors within a segment must chain.
+  for (const [index, o] of observations.entries()) {
+    const previous = observations[index - 1];
+    if (!previous) continue;
+    const open = previous.bodyPart && previous.bodyPart.index < previous.bodyPart.count - 1;
+    if ((open || (o.bodyPart && o.bodyPart.index > 0)) && !continuesBodyPart(previous, o))
+      throw new Error("body part order mismatch");
+  }
   const callId = await callIdentity(first);
   const identity = await sha256(
     new TextEncoder().encode(

package/src/component/_generated/api.ts

@@ -2,11 +2,7 @@
 
 import type * as ingest from "../ingest.js";
 import type * as queries from "../queries.js";
-import type {
-  ApiFromModules,
-  FilterApi,
-  FunctionReference,
-} from "convex/server";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
 import { anyApi, componentsGeneric } from "convex/server";
 
 const fullApi: ApiFromModules<{
@@ -15,5 +11,8 @@ const fullApi: ApiFromModules<{
 }> = anyApi as any;
 
 export const api: FilterApi<typeof fullApi, FunctionReference<any, "public">> = anyApi as any;
-export const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">> = anyApi as any;
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
 export const components = componentsGeneric() as unknown as {};

package/src/component/_generated/component.ts

@@ -10,9 +10,9 @@ type ComponentQuery<Registered, Name extends string | undefined> =
     : never;
 
 type PublicQueries<Module, Name extends string | undefined> = {
-  [Key in keyof Module as Module[Key] extends RegisteredQuery<"public", any, any>
-    ? Key
-    : never]: ComponentQuery<Module[Key], Name>;
+  [
+    Key in keyof Module as Module[Key] extends RegisteredQuery<"public", any, any> ? Key : never
+  ]: ComponentQuery<Module[Key], Name>;
 };
 
 type ComponentMutation<Registered, Name extends string | undefined> =
@@ -21,9 +21,9 @@ type ComponentMutation<Registered, Name extends string | undefined> =
     : never;
 
 type PublicMutations<Module, Name extends string | undefined> = {
-  [Key in keyof Module as Module[Key] extends RegisteredMutation<"public", any, any>
-    ? Key
-    : never]: ComponentMutation<Module[Key], Name>;
+  [
+    Key in keyof Module as Module[Key] extends RegisteredMutation<"public", any, any> ? Key : never
+  ]: ComponentMutation<Module[Key], Name>;
 };
 
 export type ComponentApi<Name extends string | undefined = string | undefined> = {

package/src/projection.ts

@@ -1,19 +1,65 @@
 import type { GenericActionCtx, GenericDataModel } from "convex/server";
 import type { CliproxyObservability } from "./client.js";
 import { resolveCallBlob, type PrivateCaptureStorage } from "./content/index.js";
-import { sha256, type CaptureObservationV1 } from "./capture/index.js";
-import { applyObservation, type ProjectionCheckpoint } from "./protocols/checkpoint.js";
+import { decodeBody, sha256, type CaptureObservationV1 } from "./capture/index.js";
+import {
+  MAX_PROJECTED_SPLIT_BYTES,
+  applyObservation,
+  type ProjectionCheckpoint,
+} from "./protocols/checkpoint.js";
+import { BodyPartAssembler } from "./protocols/body-parts.js";
 import type { ModelCallV1 } from "./model-call/index.js";
+type ProjectionContext = Pick<GenericActionCtx<GenericDataModel>, "runQuery" | "runMutation">;
+type ProjectionOptions = {
+  client: CliproxyObservability;
+  storage: PrivateCaptureStorage;
+  destinationId: string;
+  callId: string;
+};
+const segmentLines = (content: Uint8Array) =>
+  new TextDecoder("utf-8", { fatal: true }).decode(content).split("\n").filter(Boolean);
+/**
+ * A split body spans several immutable segments and projection pages. Re-read
+ * its owned segments from the first part and return the exact verified body.
+ */
+async function reassembleSplitBody(
+  ctx: ProjectionContext,
+  options: ProjectionOptions,
+  fromSegment: number,
+  final: CaptureObservationV1,
+): Promise<Uint8Array> {
+  const parts = new BodyPartAssembler();
+  const first = final.sequence - final.bodyPart!.index;
+  let after = fromSegment - 1;
+  while (after < final.sequence) {
+    const page = await ctx.runQuery(options.client.component.queries.pageEventSegments, {
+      destinationId: options.destinationId,
+      callId: options.callId,
+      afterSequence: after,
+      limit: 8,
+    });
+    if (!page.segments.length || page.segments[0]!.sequence !== after + 1)
+      throw new Error("split body segment unavailable");
+    for (const segment of page.segments) {
+      if (segment.sequence > final.sequence) break;
+      const content = await resolveCallBlob(
+        options.storage,
+        [segment.reference],
+        segment.reference,
+      );
+      for (const line of segmentLines(content)) {
+        const o = JSON.parse(line) as CaptureObservationV1;
+        if (o.sequence < first || o.sequence > final.sequence) continue;
+        const whole = await parts.push(o, decodeBody(o));
+        if (whole) return whole;
+      }
+      after = segment.throughSequence;
+    }
+  }
+  throw new Error("split body incomplete");
+}
 /** Project at most two immutable segments. Host schedules the next page when `more` is true. */
-export async function projectPendingSegments(
-  ctx: Pick<GenericActionCtx<GenericDataModel>, "runQuery" | "runMutation">,
-  options: {
-    client: CliproxyObservability;
-    storage: PrivateCaptureStorage;
-    destinationId: string;
-    callId: string;
-  },
-) {
+export async function projectPendingSegments(ctx: ProjectionContext, options: ProjectionOptions) {
   const { client, destinationId, callId } = options;
   const state = await ctx.runQuery(client.component.queries.getProcessingState, {
     destinationId,
@@ -51,11 +97,20 @@ export async function projectPendingSegments(
         [segment.reference],
         segment.reference,
       );
-      for (const line of new TextDecoder("utf-8", { fatal: true })
-        .decode(content)
-        .split("\n")
-        .filter(Boolean))
-        applyObservation(call, checkpoint, JSON.parse(line) as CaptureObservationV1);
+      for (const line of segmentLines(content)) {
+        const o = JSON.parse(line) as CaptureObservationV1;
+        const part = o.bodyPart;
+        if (part?.index === 0) checkpoint.bodyPartSegment = segment.sequence;
+        if (part && part.index === part.count - 1) {
+          if (checkpoint.bodyPartSegment === undefined) throw new Error("split body start missing");
+          const whole =
+            part.totalBytes > MAX_PROJECTED_SPLIT_BYTES
+              ? null
+              : await reassembleSplitBody(ctx, options, checkpoint.bodyPartSegment, o);
+          applyObservation(call, checkpoint, o, whole);
+          delete checkpoint.bodyPartSegment;
+        } else applyObservation(call, checkpoint, o);
+      }
       through = segment.throughSequence;
     }
     if (through === state.projectedThroughSequence)

package/src/protocols/anthropic-messages.ts

@@ -42,14 +42,46 @@ export function anthropicMessages(messages: unknown): RecordValue[] {
           content: block.content,
           is_error: block.is_error,
         });
-      } else if (block.type === "text") content.push({ type: "text", text: block.text });
-      else content.push(block);
+      } else content.push(block);
     }
     flush();
   }
   return result;
 }
 
+/** Event-local validation shared by full replay and bounded scalar checkpoints. */
+export function inspectAnthropicEvent(event: RecordValue) {
+  const type = event.type;
+  let invalid = false;
+  let unsupported = ![
+    "message_start",
+    "message_delta",
+    "message_stop",
+    "content_block_start",
+    "content_block_delta",
+    "content_block_stop",
+    "ping",
+    "error",
+  ].includes(String(type));
+  if (String(type).startsWith("content_block_")) invalid = count(event.index) === undefined;
+  if (type === "content_block_delta") {
+    const delta = object(event.delta);
+    unsupported ||= ![
+      "text_delta",
+      "thinking_delta",
+      "signature_delta",
+      "input_json_delta",
+      "citations_delta",
+    ].includes(String(delta.type));
+    if (delta.type === "citations_delta")
+      invalid ||=
+        delta.citation === null ||
+        typeof delta.citation !== "object" ||
+        Array.isArray(delta.citation);
+  }
+  return { invalid, unsupported };
+}
+
 export function assembleAnthropicStream(events: RecordValue[]) {
   let response: RecordValue = {};
   let invalid = false,
@@ -60,6 +92,9 @@ export function assembleAnthropicStream(events: RecordValue[]) {
   const blocks = new Map<number, RecordValue>();
   const argumentsByIndex = new Map<number, string>();
   for (const event of events) {
+    const inspected = inspectAnthropicEvent(event);
+    invalid ||= inspected.invalid;
+    unsupported ||= inspected.unsupported;
     const index = count(event.index);
     if (event.type === "message_start") {
       response = { ...object(event.message) };
@@ -74,12 +109,8 @@ export function assembleAnthropicStream(events: RecordValue[]) {
         invalid = true;
         continue;
       }
-      if (
-        !["text_delta", "thinking_delta", "signature_delta", "input_json_delta"].includes(
-          String(delta.type),
-        )
-      )
-        unsupported = true;
+      if (delta.type === "citations_delta" && !inspected.invalid)
+        block.citations = [...list(block.citations), delta.citation];
       for (const key of ["text", "thinking", "signature"]) append(block, key, delta[key]);
       if (typeof delta.partial_json === "string")
         argumentsByIndex.set(index, (argumentsByIndex.get(index) ?? "") + delta.partial_json);

package/src/protocols/body-parts.ts

@@ -0,0 +1,58 @@
+import {
+  MAX_BODY_PARTS,
+  MAX_CONTENT_BYTES,
+  continuesBodyPart,
+  sha256,
+  type CaptureObservationV1,
+} from "../capture/index.js";
+import { expandStockHookBlock } from "./stock-block.js";
+
+/**
+ * Reassembles native 0.2.5 split bodies from validated observations read in
+ * sequence order. `push` returns a whole observation's body unchanged, nothing
+ * for an earlier part, and the exact original body at the final part once its
+ * length and SHA-256 match. Interleaved, missing or reordered parts throw.
+ */
+export class BodyPartAssembler {
+  #open?: { previous: CaptureObservationV1; body: Uint8Array; written: number };
+  /** `maxBytes` bounds the buffer one split body may allocate. */
+  constructor(readonly maxBytes = MAX_BODY_PARTS * MAX_CONTENT_BYTES) {}
+  /** A split body has started but its final part has not been pushed. */
+  get pending(): boolean {
+    return this.#open !== undefined;
+  }
+  async push(o: CaptureObservationV1, body: Uint8Array): Promise<Uint8Array | undefined> {
+    const part = o.bodyPart;
+    const open = this.#open;
+    if (!part) {
+      if (open) throw new Error("body part interrupted");
+      return body;
+    }
+    if (part.index === 0) {
+      if (open) throw new Error("body part interrupted");
+      if (part.totalBytes > this.maxBytes) throw new Error("body part read limit");
+      this.#open = { previous: o, body: new Uint8Array(part.totalBytes), written: 0 };
+    } else if (!open || !continuesBodyPart(open.previous, o)) {
+      throw new Error("body part order mismatch");
+    }
+    const current = this.#open!;
+    if (part.offset !== current.written || body.byteLength > part.totalBytes - current.written)
+      throw new Error("body part offset mismatch");
+    current.body.set(body, part.offset);
+    current.written += body.byteLength;
+    current.previous = o;
+    if (part.index < part.count - 1) return undefined;
+    this.#open = undefined;
+    if (current.written !== part.totalBytes || (await sha256(current.body)) !== part.totalSha256)
+      throw new Error("body part digest mismatch");
+    return current.body;
+  }
+}
+
+/** Stock callbacks in a block, or the one callback a split stream body carries. */
+export function stockHookPieces(
+  o: Pick<CaptureObservationV1, "bodyPart" | "stockHookChunkLengths">,
+  body: Uint8Array,
+): readonly Uint8Array[] {
+  return o.bodyPart ? [body] : expandStockHookBlock(body, o.stockHookChunkLengths ?? []);
+}

package/src/protocols/chat-completions.ts

@@ -11,15 +11,15 @@ export function assembleChatStream(events: RecordValue[], done: boolean, stockCo
   const tools = new Map<number, Map<number, RecordValue>>();
   for (const event of events) {
     if (Array.isArray(event.choices) || event.error) recognized = true;
-    for (const key of ["id", "model", "object"])
+    else unsupported = true;
+    for (const key of ["id", "model", "object", "created", "service_tier", "system_fingerprint"])
       if (event[key] !== undefined) response[key] = event[key];
     if (event.usage !== undefined && event.usage !== null) response.usage = event.usage;
     // Final usage is emitted on an empty choices chunk or with finished choices.
     // A later [DONE] marker cannot turn an earlier running count into final usage.
-    if (Array.isArray(event.choices))
+    if (Array.isArray(event.choices) && (event.choices.length > 0 || event.usage != null))
       terminalUsage =
-        event.usage !== undefined &&
-        event.usage !== null &&
+        event.usage != null &&
         event.choices.every((choice) => typeof object(choice).finish_reason === "string");
     if (event.error) {
       response.error = event.error;
@@ -35,6 +35,15 @@ export function assembleChatStream(events: RecordValue[], done: boolean, stockCo
       const saved = choices.get(index) ?? { index, message: { role: "assistant" } };
       const message = object(saved.message);
       const delta = object(choice.delta);
+      if (typeof delta.role === "string") message.role = delta.role;
+      if (choice.logprobs !== undefined && choice.logprobs !== null) {
+        const logprobs = object(saved.logprobs);
+        for (const key of ["content", "refusal"]) {
+          const tokens = object(choice.logprobs)[key];
+          if (Array.isArray(tokens)) logprobs[key] = [...list(logprobs[key]), ...tokens];
+        }
+        saved.logprobs = logprobs;
+      }
       if (
         Object.keys(delta).some(
           (key) =>

package/src/protocols/checkpoint.ts

@@ -1,4 +1,4 @@
-import { expandStockHookBlock } from "./stock-block.js";
+import { stockHookPieces } from "./body-parts.js";
 import {
   providerIdentity,
   TOKEN_FIELDS,
@@ -7,8 +7,10 @@ import {
   type PrivateContentReference,
 } from "../model-call/index.js";
 import type { CaptureObservationV1 } from "../capture/index.js";
-import { decodeBody } from "../capture/index.js";
-import { assembleResponsesStream } from "./responses.js";
+import { continuesBodyPart, decodeBody } from "../capture/index.js";
+import { assembleResponsesStream, observeResponsesEnvelope } from "./responses.js";
+import { assembleChatStream } from "./chat-completions.js";
+import { inspectAnthropicEvent } from "./anthropic-messages.js";
 import { SSEReader, type SSECheckpoint } from "./framing.js";
 import { count, list, nanoTime, object, parseObject } from "./values.js";
 import { extractUsage } from "./usage.js";
@@ -28,6 +30,11 @@ export type ProjectionCheckpoint = {
   streamed?: boolean;
   inputSeen?: boolean;
   chatFinished?: boolean;
+  responseId?: string;
+  /** First segment of an unfinished split body; projection reassembles from there. */
+  bodyPartSegment?: number;
+  /** Last part of an unfinished split body; the next observation must continue it. */
+  openBodyPart?: Pick<CaptureObservationV1, "kind" | "sequence" | "bodyPart">;
 };
 const usageFields = [
   "input_tokens",
@@ -97,8 +104,17 @@ function observeProtocol(
   if (stream && protocol === "responses") {
     // Shared assembler determines whether the event vocabulary is supported; sequence
     // validation belongs to selected-call content replay, not this scalar checkpoint.
+    observeResponsesEnvelope(state, event);
     if (assembleResponsesStream([event]).unsupported) state.unsupported = true;
   }
+  if (stream && protocol !== "responses") {
+    const inspected =
+      protocol === "chat_completions"
+        ? assembleChatStream([event], false)
+        : inspectAnthropicEvent(event);
+    state.invalid ||= inspected.invalid;
+    state.unsupported ||= inspected.unsupported;
+  }
   if (typeof event.model === "string") call.responseModel = event.model.slice(0, 256);
   if (protocol === "responses") {
     const response = stream ? object(event.response) : event;
@@ -186,10 +202,22 @@ function observeProtocol(
     }
   }
 }
+/**
+ * Split bodies up to this size are reassembled for scalar projection. Larger ones
+ * stay complete in raw segments; projection does not allocate them in a 64 MiB
+ * Convex action.
+ */
+export const MAX_PROJECTED_SPLIT_BYTES = 8 * 1024 * 1024;
+/**
+ * Earlier parts of a split body only advance the sequence. The final part needs
+ * the exact reassembled body (`BodyPartAssembler`) as `assembled`, or `null` when
+ * the body exceeds `MAX_PROJECTED_SPLIT_BYTES` and its semantics are not projected.
+ */
 export function applyObservation(
   call: ModelCallV1,
   state: ProjectionCheckpoint,
   o: CaptureObservationV1,
+  assembled?: Uint8Array | null,
 ): void {
   if (o.sequence !== call.capture.projectedThroughSequence + 1)
     throw new Error("projection sequence gap");
@@ -204,7 +232,25 @@ export function applyObservation(
     if (!call.capture.gaps.includes(o.gap) && call.capture.gaps.length < 8)
       call.capture.gaps.push(o.gap.slice(0, 128));
   }
-  const body = decodeBody(o);
+  const part = o.bodyPart;
+  // Segments validate only their own neighbors; continuity across them is checked here.
+  if (
+    (state.openBodyPart || (part && part.index > 0)) &&
+    !(state.openBodyPart && continuesBodyPart(state.openBodyPart, o))
+  )
+    throw new Error("body part interrupted");
+  const deferred = part !== undefined && part.index < part.count - 1;
+  state.openBodyPart = deferred
+    ? { kind: o.kind, sequence: o.sequence, bodyPart: part }
+    : undefined;
+  if (part && !deferred && assembled === undefined)
+    throw new Error("split body requires reassembly");
+  const unprojected = part !== undefined && !deferred && assembled === null;
+  if (unprojected && part.totalBytes <= MAX_PROJECTED_SPLIT_BYTES)
+    throw new Error("split body within projection bound");
+  // Like an over-limit SSE frame: content is retained, its semantics are not decoded.
+  if (unprojected && o.kind !== "request") state.invalid = state.frameLimit = true;
+  const body = deferred || unprojected ? new Uint8Array() : (assembled ?? decodeBody(o));
   const decoder = new TextDecoder("utf-8", { fatal: true });
   // A new after-auth event replaces the selection, including unknown fields.
   // Stream initialization may omit auth; an explicit selection replaces the pair.
@@ -227,14 +273,21 @@ export function applyObservation(
     call.correlationConflicts = o.correlationConflicts ?? [];
     call.traceId = o.correlation?.traceId;
     call.sourceTraceId = o.sourceTraceId;
-    try {
-      const input = parseObject(decoder.decode(body));
-      state.streamed = input.stream === true;
-      call.streamed = state.streamed;
-    } catch {
-      state.invalid = true;
+    if (!deferred && !unprojected) {
+      try {
+        const input = parseObject(decoder.decode(body));
+        state.streamed = input.stream === true;
+        call.streamed = state.streamed;
+      } catch {
+        state.invalid = true;
+      }
     }
   }
+  // An unparsed request (e.g. a split body over the projection bound) takes
+  // streaming from the protocol evidence that follows it.
+  if (call.streamed === undefined && (o.kind === "stream_init" || o.kind === "stream_chunk"))
+    call.streamed = true;
+  else if (call.streamed === undefined && o.kind === "response") call.streamed = false;
   // Derived read fields: reads fill them only for summaries projected before 0.3.0.
   Object.assign(call, providerIdentity(call), { costProvenance: call.cost.kind });
   if (o.kind === "response" || o.kind === "stream_chunk" || o.kind === "completion") {
@@ -251,10 +304,7 @@ export function applyObservation(
       }
       if ((o.kind === "stream_chunk" || o.kind === "completion") && body.length) {
         const reader = new SSEReader(state.sse);
-        const pieces =
-          o.bodyFraming === "stock_hook_block"
-            ? expandStockHookBlock(body, o.stockHookChunkLengths ?? [])
-            : [body];
+        const pieces = o.bodyFraming === "stock_hook_block" ? stockHookPieces(o, body) : [body];
         const frames = pieces.flatMap((piece) =>
           o.bodyFraming === "stock_hook_chunk" || o.bodyFraming === "stock_hook_block"
             ? reader.feedStock(piece, call.clientProtocol, o.observedAt)

package/src/protocols/index.ts

@@ -10,7 +10,7 @@ export type { SSEFrame, SSECheckpoint } from "./framing.js";
 export type { CliproxyProjection, ProjectionState } from "./types.js";
 export { assembleResponsesStream, assembleChatStream, assembleAnthropicStream };
 export { nanoTime } from "./values.js";
-export const PARSER_VERSION = "client-protocol-v2";
+export const PARSER_VERSION = "client-protocol-v3";
 export function protocolForRoute(route: string): CliproxyProjection["protocol"] {
   if (route === "POST /v1/messages" || route === "POST /v1/messages/count_tokens")
     return "anthropic_messages";
@@ -99,6 +99,12 @@ export function projectCapturedPayloads(args: {
           ? assembleChatStream(events, done, args.complete === true)
           : assembleAnthropicStream(events);
     response = assembled.response;
+    if (
+      "metadataEvents" in assembled &&
+      Array.isArray(assembled.metadataEvents) &&
+      assembled.metadataEvents.length
+    )
+      projection.metadata.responseMetadata = assembled.metadataEvents;
     invalid ||= assembled.invalid;
     projection.responseState = invalid
       ? "invalid"
@@ -144,3 +150,4 @@ export function projectCapturedPayloads(args: {
 }
 
 export { expandStockHookBlock } from "./stock-block.js";
+export { BodyPartAssembler, stockHookPieces } from "./body-parts.js";