@shpitdev/convex-cliproxy-observability 0.1.0

package/src/protocols/checkpoint.ts

@@ -0,0 +1,342 @@
+import type {
+  ModelCallV1,
+  UsageMeasurement,
+  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 { SSEReader, type SSECheckpoint } from "./framing.js";
+import { count, list, nanoTime, object, parseObject } from "./values.js";
+import { extractUsage } from "./usage.js";
+import type { CliproxyProjection, RecordValue } from "./types.js";
+/** Bounded semantic state. Emitted text/tools stay in immutable content segments. */
+export type ProjectionCheckpoint = {
+  sse?: SSECheckpoint;
+  sseBlob?: PrivateContentReference;
+  usage?: RecordValue;
+  terminal?: string;
+  usageFinal?: boolean;
+  invalid?: boolean;
+  unsupported?: boolean;
+  rawGap?: boolean;
+  streamed?: boolean;
+  inputSeen?: boolean;
+  chatFinished?: boolean;
+};
+const usageFields = [
+  "input_tokens",
+  "output_tokens",
+  "total_tokens",
+  "prompt_tokens",
+  "completion_tokens",
+  "cache_read_input_tokens",
+  "cache_creation_input_tokens",
+] as const;
+function boundedUsage(value: unknown): RecordValue {
+  const raw = object(value);
+  const out: RecordValue = {};
+  for (const field of usageFields) {
+    if (count(raw[field]) !== undefined) out[field] = raw[field];
+  }
+  for (const field of [
+    "input_tokens_details",
+    "output_tokens_details",
+    "prompt_tokens_details",
+    "completion_tokens_details",
+    "cache_creation",
+  ]) {
+    const detail = object(raw[field]);
+    const safe: RecordValue = {};
+    for (const name of [
+      "cached_tokens",
+      "reasoning_tokens",
+      "thinking_tokens",
+      "ephemeral_5m_input_tokens",
+      "ephemeral_1h_input_tokens",
+    ]) {
+      if (count(detail[name]) !== undefined) safe[name] = detail[name];
+    }
+    if (Object.keys(safe).length) out[field] = safe;
+  }
+  return out;
+}
+function semantic(event: RecordValue): boolean {
+  const delta = object(event.delta);
+  return (
+    [delta.text, delta.thinking, delta.partial_json].some(
+      (x) => typeof x === "string" && x.length > 0,
+    ) ||
+    (typeof event.delta === "string" && event.delta.length > 0) ||
+    list(event.choices).some((c) => {
+      const d = object(object(c).delta);
+      return (
+        [d.content, d.reasoning_content, d.reasoning].some(
+          (x) => typeof x === "string" && x.length > 0,
+        ) || list(d.tool_calls).length > 0
+      );
+    })
+  );
+}
+function observeProtocol(
+  call: ModelCallV1,
+  state: ProjectionCheckpoint,
+  event: RecordValue,
+  stream: boolean,
+) {
+  const protocol = call.clientProtocol;
+  const type = event.type;
+  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.
+    if (assembleResponsesStream([event]).unsupported) state.unsupported = true;
+  }
+  if (typeof event.model === "string") call.responseModel = event.model.slice(0, 256);
+  if (protocol === "responses") {
+    const response = stream ? object(event.response) : event;
+    if (
+      !stream ||
+      ["response.completed", "response.failed", "response.incomplete"].includes(String(type))
+    ) {
+      const status = String(response.status);
+      if (
+        response.object !== "response" ||
+        typeof response.id !== "string" ||
+        !Array.isArray(response.output) ||
+        !["completed", "failed", "incomplete"].includes(status) ||
+        (stream && type !== `response.${status}`)
+      ) {
+        state.invalid = true;
+        return;
+      }
+      if (typeof response.model === "string") call.responseModel = response.model.slice(0, 256);
+      state.terminal = status;
+      state.usage = response.usage === undefined ? undefined : boundedUsage(response.usage);
+      state.usageFinal = response.usage !== undefined;
+      call.finishReason = status;
+    } else if (
+      ["response.created", "response.queued", "response.in_progress"].includes(String(type))
+    ) {
+      if (response.object !== "response" || typeof response.id !== "string") state.invalid = true;
+      else if (typeof response.model === "string")
+        call.responseModel = response.model.slice(0, 256);
+    } else if (type === "error") {
+      state.terminal = "failed";
+      state.usageFinal = false;
+    }
+  } else if (protocol === "anthropic_messages") {
+    if (!stream || type === "message_start") {
+      const message = stream ? object(event.message) : event;
+      if (
+        message.type !== "message" ||
+        typeof message.id !== "string" ||
+        !Array.isArray(message.content)
+      ) {
+        state.invalid = true;
+        return;
+      }
+      if (typeof message.model === "string") call.responseModel = message.model.slice(0, 256);
+      state.usage = boundedUsage(message.usage);
+      if (!stream) {
+        state.terminal = "completed";
+        state.usageFinal = message.usage !== undefined;
+        call.finishReason =
+          typeof message.stop_reason === "string" ? message.stop_reason : undefined;
+      }
+    }
+    if (type === "message_delta") {
+      state.usage = { ...state.usage, ...boundedUsage(event.usage) };
+      const reason = object(event.delta).stop_reason;
+      state.usageFinal =
+        typeof reason === "string" && count(object(event.usage).output_tokens) !== undefined;
+      if (typeof reason === "string") call.finishReason = reason;
+    }
+    if (type === "message_stop") state.terminal = "completed";
+    if (type === "error") {
+      state.terminal = "failed";
+      state.usageFinal = false;
+    }
+  } else if (protocol === "chat_completions") {
+    const choices = list(event.choices);
+    const finished = choices.every((x) => typeof object(x).finish_reason === "string");
+    if (choices.length) {
+      state.chatFinished = finished;
+      const reason = object(choices[0]).finish_reason;
+      if (typeof reason === "string") call.finishReason = reason;
+    }
+    if (event.usage !== undefined) {
+      state.usage = boundedUsage(event.usage);
+      state.usageFinal = Array.isArray(event.choices) && finished;
+    }
+    if (!stream) {
+      state.terminal = event.error ? "failed" : finished ? "completed" : undefined;
+      state.usageFinal = state.terminal === "completed" && event.usage !== undefined;
+    }
+    if (event.error) {
+      state.terminal = "failed";
+      state.usageFinal = false;
+    }
+  }
+}
+export function applyObservation(
+  call: ModelCallV1,
+  state: ProjectionCheckpoint,
+  o: CaptureObservationV1,
+): void {
+  if (o.sequence !== call.capture.projectedThroughSequence + 1)
+    throw new Error("projection sequence gap");
+  if (o.gap) {
+    state.rawGap = true;
+    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 decoder = new TextDecoder("utf-8", { fatal: true });
+  if (o.kind === "request") {
+    state.inputSeen = true;
+    if (o.requestedModel) call.requestModel = o.requestedModel.slice(0, 256);
+    call.correlation = o.correlation ?? {};
+    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 (o.kind === "response" || o.kind === "stream_chunk" || o.kind === "completion") {
+    if (call.timeToFirstByteMs === undefined && (o.observedBodyBytes ?? body.length) > 0)
+      call.timeToFirstByteMs = o.offsetNs / 1e6;
+    try {
+      if (o.kind === "response" && body.length) {
+        const event = parseObject(decoder.decode(body));
+        if (call.operation === "generation") observeProtocol(call, state, event, false);
+        else {
+          state.terminal = "completed";
+          if (call.operation === "token_count") call.tokenCount = count(event.input_tokens);
+        }
+      }
+      if ((o.kind === "stream_chunk" || o.kind === "completion") && body.length) {
+        const reader = new SSEReader(state.sse);
+        for (const frame of reader.feed(body, o.observedAt)) {
+          if (frame.data === "[DONE]") {
+            if (call.clientProtocol === "chat_completions" && state.chatFinished)
+              state.terminal = "completed";
+            continue;
+          }
+          const event = parseObject(frame.data);
+          if (call.timeToFirstContentMs === undefined && semantic(event))
+            call.timeToFirstContentMs = o.offsetNs / 1e6;
+          observeProtocol(call, state, event, true);
+        }
+        state.sse = reader.checkpoint();
+      }
+    } catch {
+      state.invalid = true;
+    }
+  }
+  if (o.kind === "completion") {
+    try {
+      if (new SSEReader(state.sse).finish().truncated) state.invalid = true;
+    } catch {
+      state.invalid = true;
+    }
+    delete state.sse;
+    delete state.sseBlob;
+    if (
+      call.clientProtocol === "chat_completions" &&
+      state.chatFinished &&
+      o.completionOutcome === "succeeded"
+    )
+      state.terminal = "completed";
+    call.completionOutcome = o.completionOutcome;
+    call.executionStatusCode = o.executionStatusCode;
+    call.endTimeUnixNano = nanoTime(o.executionCompletedAt);
+    const start = nanoTime(o.executionStartedAt);
+    if (start) call.startTimeUnixNano = start;
+    if (start && call.endTimeUnixNano)
+      call.latencyMs = Number(BigInt(call.endTimeUnixNano) - BigInt(start)) / 1e6;
+    call.capture.terminalSequence = o.sequence;
+    call.state =
+      o.completionOutcome === "canceled"
+        ? "aborted"
+        : o.completionOutcome === "failed"
+          ? "failed"
+          : o.completionOutcome === "rejected"
+            ? "rejected"
+            : state.terminal === "completed"
+              ? "succeeded"
+              : state.terminal === "failed" || state.terminal === "incomplete"
+                ? "failed"
+                : "unknown";
+  }
+  call.protocolTerminal = state.terminal;
+  const final =
+    !!state.terminal && state.usageFinal && !state.invalid && !state.unsupported && !state.rawGap;
+  const projection: CliproxyProjection = {
+    version: 1,
+    protocol: call.clientProtocol ?? "unknown",
+    requestState: "absent",
+    responseState: final ? "decoded" : "truncated",
+    scalars: {},
+    metadata: {},
+  };
+  if (state.usage && call.operation === "generation") {
+    extractUsage(projection, state.usage);
+    const measurements: UsageMeasurement[] = [];
+    for (const field of usageFields) {
+      const value = count(state.usage[field]);
+      if (value !== undefined)
+        measurements.push({
+          value,
+          nativeField: field,
+          source: "client_protocol",
+          scope: "call",
+          unit: "tokens",
+          finality: final ? "final" : "partial",
+          semanticsVersion: String(projection.metadata.tokenSemantics),
+        });
+    }
+    for (const [key, detail] of Object.entries(state.usage)) {
+      if (!detail || typeof detail !== "object") continue;
+      for (const [field, raw] of Object.entries(detail)) {
+        const value = count(raw);
+        if (value !== undefined)
+          measurements.push({
+            value,
+            nativeField: `${key}.${field}`,
+            source: "client_protocol",
+            scope: "call",
+            unit: "tokens",
+            finality: final ? "final" : "partial",
+            semanticsVersion: String(projection.metadata.tokenSemantics),
+          });
+      }
+    }
+    call.usage = measurements;
+    for (const field of [
+      "inputTokens",
+      "outputTokens",
+      "totalTokens",
+      "reasoningTokens",
+      "cachedInputTokens",
+    ] as const)
+      call[field] = final ? projection.scalars[field] : undefined;
+  }
+  call.capture.lastObservedAt = o.observedAt;
+  call.capture.projectedThroughSequence = o.sequence;
+  call.capture.persistedThroughSequence = o.sequence;
+  call.capture.raw =
+    call.capture.terminalSequence === o.sequence && !state.rawGap ? "complete" : "partial";
+  call.capture.projection = state.invalid
+    ? "invalid"
+    : state.unsupported
+      ? "unsupported"
+      : state.terminal
+        ? "complete"
+        : "partial";
+  call.capture.usage = call.usage.length ? (final ? "complete" : "partial") : "unavailable";
+}

package/src/protocols/content.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+const toolCall = z.object({
+  id: z.string(),
+  type: z.literal("function"),
+  function: z.object({ name: z.string(), arguments: z.string() }),
+});
+const message = z
+  .object({
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    tool_call_id: z.string().optional(),
+    tool_calls: z.array(toolCall).optional(),
+  })
+  .loose();
+const output = z.object({
+  format: z.literal("cliproxy_response_v1"),
+  protocol: z.enum(["chat_completions", "anthropic_messages", "responses"]),
+  completion: z.string(),
+  reasoning: z.string(),
+  messages: z.array(message),
+  native: z.record(z.string(), z.unknown()),
+});
+export type CliproxyOutput = z.infer<typeof output>;
+export function decodeCliproxyOutput(
+  raw?: string,
+):
+  | { state: "absent" | "invalid" | "unsupported" | "truncated" }
+  | { state: "decoded"; content: CliproxyOutput } {
+  if (raw === undefined) return { state: "absent" };
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { state: "invalid" };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { state: "unsupported" };
+  if (!("format" in value) || value.format !== "cliproxy_response_v1")
+    return { state: "unsupported" };
+  const parsed = output.safeParse(value);
+  return parsed.success ? { state: "decoded", content: parsed.data } : { state: "invalid" };
+}

package/src/protocols/framing.ts

@@ -0,0 +1,62 @@
+/** Incremental SSE framing. Times belong to the observation containing the final byte. */
+export type SSEFrame = { data: string; event?: string; observedAt?: string };
+export type SSECheckpoint = { pendingBase64: string };
+export class SSEReader {
+  private pending: Uint8Array;
+  constructor(
+    checkpoint: SSECheckpoint = { pendingBase64: "" },
+    private maxBytes = 1024 * 1024,
+  ) {
+    this.pending = Uint8Array.from(atob(checkpoint.pendingBase64), (c) => c.charCodeAt(0));
+    if (this.pending.length > maxBytes) throw new Error("SSE frame limit");
+  }
+  feed(bytes: Uint8Array, observedAt?: string): SSEFrame[] {
+    const combined = new Uint8Array(this.pending.length + bytes.length);
+    combined.set(this.pending);
+    combined.set(bytes, this.pending.length);
+    const frames: SSEFrame[] = [];
+    let start = 0;
+    for (let i = 0; i < combined.length; i++) {
+      const delimiter =
+        combined[i] === 13 &&
+        combined[i + 1] === 10 &&
+        combined[i + 2] === 13 &&
+        combined[i + 3] === 10
+          ? 4
+          : combined[i] === 10 && combined[i + 1] === 10
+            ? 2
+            : combined[i] === 13 && combined[i + 1] === 13
+              ? 2
+              : 0;
+      if (i - start > this.maxBytes) throw new Error("SSE frame limit");
+      if (!delimiter) continue;
+      const block = new TextDecoder("utf-8", { fatal: true }).decode(combined.subarray(start, i));
+      const data: string[] = [];
+      let event: string | undefined;
+      for (const line of block.split(/\r\n|\r|\n/)) {
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        const value = (colon < 0 ? "" : line.slice(colon + 1)).replace(/^ /, "");
+        if (field === "data") data.push(value);
+        else if (field === "event") event = value;
+      }
+      if (data.length) frames.push({ data: data.join("\n"), event, observedAt });
+      i += delimiter - 1;
+      start = i + 1;
+    }
+    this.pending = combined.slice(start);
+    if (this.pending.length > this.maxBytes) throw new Error("SSE frame limit");
+    return frames;
+  }
+  finish(): { truncated: boolean } {
+    return {
+      truncated: new TextDecoder("utf-8", { fatal: true }).decode(this.pending).trim().length > 0,
+    };
+  }
+  checkpoint(): SSECheckpoint {
+    let raw = "";
+    for (const byte of this.pending) raw += String.fromCharCode(byte);
+    return { pendingBase64: btoa(raw) };
+  }
+}

package/src/protocols/index.ts

@@ -0,0 +1,140 @@
+import { assembleResponsesStream } from "./responses.js";
+import { assembleChatStream } from "./chat-completions.js";
+import { assembleAnthropicStream } from "./anthropic-messages.js";
+import { SSEReader } from "./framing.js";
+import { object, parseObject } from "./values.js";
+import { requestInput, responseOutput } from "./output.js";
+import type { CliproxyProjection, RecordValue } from "./types.js";
+export { SSEReader } from "./framing.js";
+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-v1";
+export function protocolForRoute(route: string): CliproxyProjection["protocol"] {
+  if (route === "POST /v1/messages" || route === "POST /v1/messages/count_tokens")
+    return "anthropic_messages";
+  if (route === "POST /v1/responses") return "responses";
+  if (route === "POST /v1/chat/completions") return "chat_completions";
+  return "unknown";
+}
+/** Bounded replay helper for fixtures and selected-call export; never fetches data itself. */
+export function projectCapturedPayloads(args: {
+  route: string;
+  request?: Uint8Array;
+  response?: Uint8Array;
+  chunks?: readonly Uint8Array[];
+  complete?: boolean;
+}): CliproxyProjection {
+  const projection: CliproxyProjection = {
+    version: 1,
+    protocol: protocolForRoute(args.route),
+    requestState: "absent",
+    responseState: "absent",
+    scalars: {},
+    metadata: { parserVersion: PARSER_VERSION, providerIdentity: "unavailable" },
+  };
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  if (args.request) {
+    try {
+      const req = parseObject(decoder.decode(args.request));
+      projection.input = requestInput(projection.protocol, req);
+      projection.requestState = "decoded";
+      if (typeof req.model === "string") projection.scalars.requestModel = req.model;
+      if (typeof req.stream === "boolean") projection.scalars.streamed = req.stream;
+    } catch {
+      projection.requestState = "invalid";
+    }
+  }
+  let response: RecordValue = {};
+  if (args.response) {
+    try {
+      response = parseObject(decoder.decode(args.response));
+      projection.responseState = "decoded";
+      projection.metadata.terminalObserved = true;
+      projection.metadata.usageState = response.usage ? "terminal_snapshot" : "absent";
+    } catch {
+      projection.responseState = "invalid";
+    }
+  }
+  if (args.chunks) {
+    const reader = new SSEReader();
+    const events: RecordValue[] = [];
+    let done = false;
+    let invalid = false;
+    let bytes = 0;
+    for (const chunk of args.chunks) {
+      bytes += chunk.byteLength;
+      if (bytes > 16 * 1024 * 1024)
+        throw new Error("bounded replay limit; use event pages for larger calls");
+      try {
+        for (const frame of reader.feed(chunk)) {
+          if (frame.data === "[DONE]") {
+            done = true;
+            continue;
+          }
+          try {
+            events.push(parseObject(frame.data));
+          } catch {
+            invalid = true;
+          }
+        }
+      } catch {
+        invalid = true;
+      }
+    }
+    try {
+      invalid ||= reader.finish().truncated;
+    } catch {
+      invalid = true;
+    }
+    const assembled =
+      projection.protocol === "responses"
+        ? assembleResponsesStream(events)
+        : projection.protocol === "chat_completions"
+          ? assembleChatStream(events, done, args.complete === true)
+          : assembleAnthropicStream(events);
+    response = assembled.response;
+    invalid ||= assembled.invalid;
+    projection.responseState = invalid
+      ? "invalid"
+      : !assembled.recognized || assembled.unsupported
+        ? "unsupported"
+        : assembled.terminal
+          ? "decoded"
+          : "truncated";
+    projection.metadata.terminalObserved = assembled.terminal;
+    const final =
+      assembled.terminalUsage &&
+      assembled.terminal &&
+      !invalid &&
+      assembled.recognized &&
+      !assembled.unsupported;
+    projection.metadata.usageState =
+      final && response.usage
+        ? "terminal_snapshot"
+        : response.usage
+          ? "partial_snapshot"
+          : "absent";
+    if (!final) {
+      projection.metadata.partialUsage = response.usage;
+      delete response.usage;
+    }
+  }
+  if (projection.protocol !== "unknown" && (args.response || args.chunks))
+    responseOutput(projection, response);
+  if (projection.protocol === "responses" && typeof response.status === "string")
+    projection.scalars.statusJson = JSON.stringify({ responseStatus: response.status });
+  if (args.route === "POST /v1/messages/count_tokens") {
+    projection.metadata.operation = "token_count";
+    projection.metadata.tokenCount = object(response).input_tokens;
+    projection.scalars.inputTokens = undefined;
+    projection.scalars.outputTokens = undefined;
+    projection.scalars.totalTokens = undefined;
+  }
+  if (args.route === "GET /v1/models") {
+    projection.metadata.operation = "discovery";
+    projection.output = { native: response };
+  }
+  return projection;
+}

package/src/protocols/output.ts

@@ -0,0 +1,78 @@
+import type { CliproxyProjection, RecordValue } from "./types.js";
+import { identity, list, object } from "./values.js";
+import { extractUsage } from "./usage.js";
+import { responsesMessages } from "./responses.js";
+import { anthropicMessages } from "./anthropic-messages.js";
+export function requestInput(
+  protocol: CliproxyProjection["protocol"],
+  request: RecordValue,
+): RecordValue {
+  if (protocol === "anthropic_messages") {
+    const messages = anthropicMessages(request.messages);
+    if (request.system !== undefined) messages.unshift({ role: "system", content: request.system });
+    return { ...request, messages, nativeMessages: request.messages };
+  }
+  if (protocol === "responses") {
+    const { input, ...rest } = request;
+    return {
+      ...rest,
+      messages: [
+        ...(typeof request.instructions === "string"
+          ? [{ role: "system", content: request.instructions }]
+          : []),
+        ...(typeof input === "string" ? [{ role: "user", content: input }] : list(input)),
+      ],
+      nativeInput: input,
+    };
+  }
+  return request;
+}
+export function responseOutput(projection: CliproxyProjection, response: RecordValue) {
+  projection.scalars.responseModel = identity(response.model);
+  projection.scalars.generationId = identity(response.id);
+  if (projection.responseState === "decoded" && response.usage !== undefined)
+    extractUsage(projection, object(response.usage));
+  let messages: RecordValue[];
+  if (projection.protocol === "chat_completions") {
+    const choices = list(response.choices);
+    messages = choices.map((raw) => ({
+      ...object(object(raw).message),
+      choiceIndex: object(raw).index,
+      finishReason: object(raw).finish_reason,
+    }));
+    projection.scalars.finishReason = identity(object(choices[0]).finish_reason);
+  } else if (projection.protocol === "responses") {
+    messages = responsesMessages(response.output);
+    projection.scalars.finishReason = identity(response.status);
+  } else {
+    messages = anthropicMessages([{ role: "assistant", content: response.content }]);
+    projection.scalars.finishReason = identity(response.stop_reason);
+  }
+  const first = messages[0] ?? {};
+  const text: string[] = [];
+  const reasoning: string[] = [];
+  const selected = projection.protocol === "chat_completions" ? [first] : messages;
+  for (const message of selected) {
+    if (typeof message.content === "string") text.push(message.content);
+    if (typeof message.reasoning_content === "string") reasoning.push(message.reasoning_content);
+    if (typeof message.reasoning === "string") reasoning.push(message.reasoning);
+    for (const raw of [...list(message.content), ...list(message.summary)]) {
+      const block = object(raw);
+      if (["text", "output_text"].includes(String(block.type)) && typeof block.text === "string")
+        text.push(block.text);
+      if (block.type === "thinking" && typeof block.thinking === "string")
+        reasoning.push(block.thinking);
+      if (block.type === "summary_text" && typeof block.text === "string")
+        reasoning.push(block.text);
+    }
+  }
+  projection.output = {
+    format: "cliproxy_response_v1",
+    protocol: projection.protocol,
+    completion: text.join(""),
+    reasoning: reasoning.join(""),
+    messages,
+    // Native blocks preserve signatures, tool results, refusal, unknown content and errors.
+    native: response,
+  };
+}