@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/chunk-4YDDHSO2.js

@@ -0,0 +1,799 @@
+import {
+  retainedOutputUnavailable,
+  validateRetainedOutputEvidence
+} from "./chunk-UH4K7GP7.js";
+
+// src/event-preview.ts
+var SESSION_EVENT_PAYLOAD_MAX_BYTES = 64 * 1024;
+var TOOL_CALL_OUTPUT_EVENT_MAX_BYTES = 256 * 1024;
+var TOOL_CALL_OUTPUT_EVENT_STRING_BYTES = 64 * 1024;
+var TARGET_PAYLOAD_BYTES = 60 * 1024;
+var DEFAULT_STRING_BYTES = 8 * 1024;
+var RETRY_STRING_BYTES = 1024;
+var DEFAULT_ARRAY_ENTRIES = 40;
+var RETRY_ARRAY_ENTRIES = 12;
+var DEFAULT_OBJECT_FIELDS = 80;
+var RETRY_OBJECT_FIELDS = 32;
+var MAX_PREVIEW_DEPTH = 12;
+var MAX_PREVIEW_NODES = 512;
+var MAX_MEASUREMENT_NODES = 2048;
+var MAX_MEASUREMENT_DEPTH = 64;
+var MAX_DETAIL_RECORDS = 24;
+var APPROX_BYTES_PER_TOKEN = 4;
+var encoder = new TextEncoder();
+var IDENTITY_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "callId",
+  "call_id",
+  "name",
+  "toolName",
+  "type",
+  "status",
+  "code",
+  "isError",
+  "stream",
+  "commandId",
+  "sequence"
+]);
+function sessionEventJsonBytes(value) {
+  return encoder.encode(stringifyForBoundary(value)).byteLength;
+}
+function measureSessionEventJson(value) {
+  return measureJsonBytes(value);
+}
+function approximateSessionEventTokens(bytes) {
+  return Math.ceil(Math.max(0, bytes) / APPROX_BYTES_PER_TOKEN);
+}
+function sessionEventMediaPreview(mediaType, inlineBytes) {
+  return {
+    type: "media_preview",
+    mediaType: mediaType || "application/octet-stream",
+    inlineBytes: inlineBytes === null ? null : Math.max(0, Math.floor(Number.isFinite(inlineBytes) ? inlineBytes : 0)),
+    fullOutputAvailable: false,
+    preview: "Inline media omitted from the audit timeline; source bytes were not retained."
+  };
+}
+function sessionEventMediaPreviewFromDataUrl(value) {
+  const match = /^data:([^;,]+)(?:;[^,]*)?;base64,/i.exec(value);
+  if (!match) return null;
+  const encodedLength = Math.max(0, value.length - match[0].length);
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return sessionEventMediaPreview(
+    match[1] ?? "application/octet-stream",
+    Math.max(0, Math.floor(encodedLength * 3 / 4) - padding)
+  );
+}
+function sessionEventPayloadTruncation(payload) {
+  if (!isPlainRecord(payload)) return null;
+  const value = payload.truncation;
+  if (!isPlainRecord(value) || value.truncated !== true) return null;
+  return value;
+}
+function boundSessionEventPayload(payload, options = {}) {
+  const maxBytes = Math.max(1024, Math.floor(options.maxBytes ?? SESSION_EVENT_PAYLOAD_MAX_BYTES));
+  const surface = options.surface ?? "durable_audit";
+  const customStringBytes = options.stringBytes === void 0 ? null : Math.max(RETRY_STRING_BYTES, Math.floor(options.stringBytes));
+  const stringBytes = customStringBytes ?? DEFAULT_STRING_BYTES;
+  const retryStringBytes = customStringBytes === null ? RETRY_STRING_BYTES : Math.max(RETRY_STRING_BYTES, Math.floor(customStringBytes / 8));
+  const targetBytes = customStringBytes === null ? Math.min(maxBytes, TARGET_PAYLOAD_BYTES) : maxBytes;
+  const fullEvidence = validateRetainedOutputEvidence(options.fullEvidence) ?? retainedOutputUnavailable();
+  const originalMeasurement = measureJsonBytes(payload);
+  const originalBytes = originalMeasurement.bytes;
+  let state = previewState(stringBytes, DEFAULT_ARRAY_ENTRIES, DEFAULT_OBJECT_FIELDS);
+  let preview = previewValue(payload, state, "$", 0);
+  if (!state.changed && originalBytes !== null && originalBytes <= maxBytes) {
+    return payload;
+  }
+  let reason = payloadTruncationReason(originalMeasurement, state);
+  let bounded = attachTruncation(
+    preview,
+    boundaryMetadata(surface, reason, originalBytes, state, fullEvidence)
+  );
+  if (sessionEventJsonBytes(bounded) > targetBytes) {
+    state = previewState(retryStringBytes, RETRY_ARRAY_ENTRIES, RETRY_OBJECT_FIELDS);
+    preview = previewValue(payload, state, "$", 0);
+    reason = payloadTruncationReason(originalMeasurement, state);
+    bounded = attachTruncation(
+      preview,
+      boundaryMetadata(surface, reason, originalBytes, state, fullEvidence)
+    );
+  }
+  if (sessionEventJsonBytes(bounded) > maxBytes) {
+    const identity = identityPreview(payload);
+    state.changed = true;
+    recordDetail(state, {
+      path: "$",
+      kind: "object",
+      ...originalBytes === null ? {} : { originalBytes }
+    });
+    bounded = attachTruncation(
+      {
+        ...identity,
+        preview: "[event payload omitted: bounded audit preview exceeded the storage envelope]"
+      },
+      boundaryMetadata(surface, reason, originalBytes, state, fullEvidence)
+    );
+  }
+  settleDeliveredSizes(bounded, maxBytes);
+  return bounded;
+}
+function boundSessionEventPayloadForWrite(type, payload) {
+  if (type !== "agent.toolCall.output") return payload;
+  let bytes;
+  try {
+    bytes = sessionEventJsonBytes(payload);
+  } catch {
+    bytes = null;
+  }
+  if (bytes !== null && bytes <= TOOL_CALL_OUTPUT_EVENT_MAX_BYTES) return payload;
+  return boundSessionEventPayload(payload, {
+    surface: "durable_audit",
+    maxBytes: TOOL_CALL_OUTPUT_EVENT_MAX_BYTES,
+    stringBytes: TOOL_CALL_OUTPUT_EVENT_STRING_BYTES
+  });
+}
+function previewState(stringBytes, arrayEntries, objectFields) {
+  return {
+    changed: false,
+    sawMedia: false,
+    details: [],
+    stringBytes,
+    arrayEntries,
+    objectFields,
+    remainingNodes: MAX_PREVIEW_NODES
+  };
+}
+function payloadTruncationReason(measurement, state) {
+  if (state.sawMedia) return "inline_media_not_retained";
+  return measurement.bytes === null ? measurement.reason : "payload_bytes_exceeded";
+}
+function previewValue(value, state, path, depth) {
+  if (state.remainingNodes <= 0) {
+    state.changed = true;
+    recordDetail(state, { path, kind: "budget" });
+    return "[nested value omitted at audit preview traversal boundary]";
+  }
+  state.remainingNodes -= 1;
+  if (typeof value === "string") {
+    const media = inlineMediaFact(value);
+    if (media) {
+      state.changed = true;
+      state.sawMedia = true;
+      recordDetail(state, {
+        path,
+        kind: "media",
+        originalBytes: utf8Bytes(value),
+        deliveredBytes: sessionEventJsonBytes(media),
+        mediaType: media.mediaType
+      });
+      return media;
+    }
+    const originalBytes = utf8Bytes(value);
+    if (originalBytes <= state.stringBytes) return value;
+    state.changed = true;
+    const delivered = truncateUtf8Middle(value, state.stringBytes, originalBytes);
+    recordDetail(state, {
+      path,
+      kind: "string",
+      originalBytes,
+      deliveredBytes: utf8Bytes(delivered)
+    });
+    return delivered;
+  }
+  if (typeof value === "bigint" || typeof value === "function" || typeof value === "symbol") {
+    state.changed = true;
+    recordDetail(state, { path, kind: "unserializable" });
+    return `[${typeof value} value omitted at audit serialization boundary]`;
+  }
+  if (value === null || typeof value !== "object") return value;
+  const binary = binaryFact(value);
+  if (binary) {
+    state.changed = true;
+    recordDetail(state, {
+      path,
+      kind: "binary",
+      originalBytes: binary.originalBytes,
+      deliveredBytes: sessionEventJsonBytes(binary.preview)
+    });
+    return binary.preview;
+  }
+  if (depth >= MAX_PREVIEW_DEPTH) {
+    state.changed = true;
+    recordDetail(state, { path, kind: "depth" });
+    return "[nested value omitted at audit preview depth boundary]";
+  }
+  if (Array.isArray(value)) {
+    const keep = Math.max(2, state.arrayEntries);
+    if (value.length <= keep) {
+      return Array.from(
+        { length: value.length },
+        (_, index) => previewArrayEntry(value, index, state, path, depth)
+      );
+    }
+    state.changed = true;
+    const head = Math.ceil(keep / 2);
+    const tail = Math.floor(keep / 2);
+    const omitted2 = value.length - head - tail;
+    recordDetail(state, { path, kind: "array", omittedEntries: omitted2 });
+    return [
+      ...Array.from(
+        { length: head },
+        (_, index) => previewArrayEntry(value, index, state, path, depth)
+      ),
+      { omittedEntries: omitted2, preview: "[middle array entries omitted]" },
+      ...Array.from(
+        { length: tail },
+        (_, index) => previewArrayEntry(value, value.length - tail + index, state, path, depth)
+      )
+    ];
+  }
+  if (value instanceof Date) {
+    if (!hasCanonicalDateSerialization(value)) {
+      state.changed = true;
+      recordDetail(state, { path, kind: "unserializable" });
+      return "[Date value with custom serialization omitted at audit boundary]";
+    }
+    try {
+      const epoch = Date.prototype.getTime.call(value);
+      return Number.isFinite(epoch) ? Date.prototype.toISOString.call(value) : null;
+    } catch {
+      state.changed = true;
+      recordDetail(state, { path, kind: "unserializable" });
+      return "[Date value omitted at audit serialization boundary]";
+    }
+  }
+  const record = value;
+  const { entries, omitted, accessorKeys } = selectObjectEntries(record, state.objectFields);
+  for (const key of accessorKeys) {
+    state.changed = true;
+    recordDetail(state, {
+      path: `${path}.${key}`,
+      kind: "unserializable"
+    });
+  }
+  if (omitted) {
+    state.changed = true;
+    recordDetail(state, {
+      path,
+      kind: "object",
+      // Counting every remaining field would defeat the traversal bound. `null`
+      // is deliberate: at least one field was omitted, but its exact count is
+      // unknown because the source was not fully enumerated.
+      omittedEntries: null
+    });
+  }
+  const out = {};
+  for (const [key, entry] of entries) {
+    out[key] = previewValue(entry, state, `${path}.${key}`, depth + 1);
+  }
+  if (omitted) {
+    out.omittedFields = "additional fields omitted; exact count not measured";
+  }
+  return out;
+}
+function previewArrayEntry(value, index, state, path, depth) {
+  let descriptor;
+  try {
+    descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+  } catch {
+    state.changed = true;
+    recordDetail(state, { path: `${path}[${index}]`, kind: "unserializable" });
+    return "[array element omitted at audit serialization boundary]";
+  }
+  if (descriptor && !("value" in descriptor)) {
+    state.changed = true;
+    recordDetail(state, { path: `${path}[${index}]`, kind: "unserializable" });
+    return "[array accessor value omitted at audit serialization boundary]";
+  }
+  return previewValue(
+    descriptor && "value" in descriptor ? descriptor.value : void 0,
+    state,
+    `${path}[${index}]`,
+    depth + 1
+  );
+}
+function selectObjectEntries(record, maxFields) {
+  const entries = [];
+  const selected = /* @__PURE__ */ new Set();
+  const accessorKeys = [];
+  const select = (key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (!descriptor?.enumerable) return false;
+    selected.add(key);
+    if ("value" in descriptor) {
+      entries.push([key, descriptor.value]);
+    } else {
+      entries.push([key, "[accessor value omitted at audit serialization boundary]"]);
+      accessorKeys.push(key);
+    }
+    return true;
+  };
+  try {
+    for (const key of IDENTITY_FIELDS) {
+      if (entries.length >= maxFields) break;
+      select(key);
+    }
+    for (const key in record) {
+      if (!Object.prototype.hasOwnProperty.call(record, key) || selected.has(key)) continue;
+      if (entries.length >= maxFields) {
+        return { entries, omitted: true, accessorKeys };
+      }
+      select(key);
+    }
+  } catch {
+    return { entries, omitted: true, accessorKeys };
+  }
+  return { entries, omitted: false, accessorKeys };
+}
+function attachTruncation(preview, truncation) {
+  if (isPlainRecord(preview)) {
+    return { ...preview, truncation };
+  }
+  return { value: preview, truncation };
+}
+function boundaryMetadata(surface, reason, originalBytes, state, fullEvidence) {
+  return {
+    truncated: true,
+    surface,
+    reason,
+    originalBytes,
+    deliveredBytes: 0,
+    omittedBytes: originalBytes,
+    estimatedOriginalTokens: originalBytes === null ? null : approximateSessionEventTokens(originalBytes),
+    estimatedDeliveredTokens: 0,
+    fullEvidence,
+    details: state.details
+  };
+}
+function settleDeliveredSizes(payload, maxBytes) {
+  const truncation = payload.truncation;
+  convergeDeliveredSizes(payload, truncation);
+  if (sessionEventJsonBytes(payload) > maxBytes) {
+    payload.preview = "[event payload omitted at audit byte boundary]";
+    for (const key of Object.keys(payload)) {
+      if (key !== "preview" && key !== "truncation" && IDENTITY_FIELDS.has(key) === false) {
+        delete payload[key];
+      }
+    }
+    truncation.details = truncation.details.slice(0, 4);
+    convergeDeliveredSizes(payload, truncation);
+  }
+}
+function convergeDeliveredSizes(payload, truncation) {
+  for (let attempt = 0; attempt < 16; attempt += 1) {
+    const deliveredBytes = sessionEventJsonBytes(payload);
+    const omittedBytes = truncation.originalBytes === null ? null : Math.max(0, truncation.originalBytes - deliveredBytes);
+    const estimatedDeliveredTokens = approximateSessionEventTokens(deliveredBytes);
+    if (truncation.deliveredBytes === deliveredBytes && truncation.omittedBytes === omittedBytes && truncation.estimatedDeliveredTokens === estimatedDeliveredTokens) {
+      return;
+    }
+    truncation.deliveredBytes = deliveredBytes;
+    truncation.omittedBytes = omittedBytes;
+    truncation.estimatedDeliveredTokens = estimatedDeliveredTokens;
+  }
+  throw new RangeError("Session event byte accounting did not converge");
+}
+function recordDetail(state, detail) {
+  if (state.details.length < MAX_DETAIL_RECORDS) state.details.push(detail);
+}
+function identityPreview(value) {
+  if (!isPlainRecord(value)) return {};
+  const out = {};
+  for (const key of IDENTITY_FIELDS) {
+    let field;
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+      field = descriptor.value;
+    } catch {
+      continue;
+    }
+    if (typeof field === "string") {
+      out[key] = truncateUtf8Middle(field, 256, utf8Bytes(field));
+    } else if (typeof field === "number" || typeof field === "boolean" || field === null) {
+      out[key] = field;
+    }
+  }
+  return out;
+}
+function inlineMediaFact(value) {
+  return sessionEventMediaPreviewFromDataUrl(value);
+}
+function binaryFact(value) {
+  if (ArrayBuffer.isView(value)) {
+    return {
+      originalBytes: value.byteLength,
+      preview: {
+        type: "binary_preview",
+        byteLength: value.byteLength,
+        fullOutputAvailable: false,
+        preview: "Inline binary value omitted from the audit timeline; bytes were not retained."
+      }
+    };
+  }
+  if (value instanceof ArrayBuffer) {
+    return {
+      originalBytes: value.byteLength,
+      preview: {
+        type: "binary_preview",
+        byteLength: value.byteLength,
+        fullOutputAvailable: false,
+        preview: "Inline binary value omitted from the audit timeline; bytes were not retained."
+      }
+    };
+  }
+  return null;
+}
+function truncateUtf8Middle(value, maxBytes, knownBytes = utf8Bytes(value)) {
+  if (knownBytes <= maxBytes) return value;
+  let omittedBytes = Math.max(0, knownBytes - maxBytes);
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const marker2 = `\u2026[${omittedBytes} bytes omitted]\u2026`;
+    const contentBudget2 = Math.max(0, maxBytes - utf8Bytes(marker2));
+    if (contentBudget2 === 0) return marker2;
+    const left2 = utf8Prefix(value, Math.floor(contentBudget2 / 2));
+    const right2 = utf8Suffix(value, contentBudget2 - left2.bytes);
+    const exactOmittedBytes = Math.max(0, knownBytes - left2.bytes - right2.bytes);
+    if (exactOmittedBytes === omittedBytes) {
+      return `${value.slice(0, left2.end)}${marker2}${value.slice(right2.start)}`;
+    }
+    omittedBytes = exactOmittedBytes;
+  }
+  const marker = `\u2026[${omittedBytes} bytes omitted]\u2026`;
+  const contentBudget = Math.max(0, maxBytes - utf8Bytes(marker));
+  const left = utf8Prefix(value, Math.floor(contentBudget / 2));
+  const right = utf8Suffix(value, contentBudget - left.bytes);
+  return `${value.slice(0, left.end)}${marker}${value.slice(right.start)}`;
+}
+function utf8Prefix(value, maxBytes) {
+  let end = 0;
+  let bytes = 0;
+  while (end < value.length) {
+    const unit = utf8UnitAt(value, end);
+    if (bytes + unit.bytes > maxBytes) break;
+    bytes += unit.bytes;
+    end += unit.codeUnits;
+  }
+  return { end, bytes };
+}
+function utf8Suffix(value, maxBytes) {
+  let start = value.length;
+  let bytes = 0;
+  while (start > 0) {
+    const unit = utf8UnitBefore(value, start);
+    if (bytes + unit.bytes > maxBytes) break;
+    bytes += unit.bytes;
+    start -= unit.codeUnits;
+  }
+  return { start, bytes };
+}
+function utf8UnitAt(value, index) {
+  const code = value.charCodeAt(index);
+  if (code <= 127) return { codeUnits: 1, bytes: 1 };
+  if (code <= 2047) return { codeUnits: 1, bytes: 2 };
+  if (code >= 55296 && code <= 56319) {
+    const next = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+    if (next >= 56320 && next <= 57343) {
+      return { codeUnits: 2, bytes: 4 };
+    }
+  }
+  return { codeUnits: 1, bytes: 3 };
+}
+function utf8UnitBefore(value, end) {
+  const code = value.charCodeAt(end - 1);
+  if (code >= 56320 && code <= 57343 && end >= 2) {
+    const previous = value.charCodeAt(end - 2);
+    if (previous >= 55296 && previous <= 56319) {
+      return { codeUnits: 2, bytes: 4 };
+    }
+  }
+  if (code <= 127) return { codeUnits: 1, bytes: 1 };
+  if (code <= 2047) return { codeUnits: 1, bytes: 2 };
+  return { codeUnits: 1, bytes: 3 };
+}
+function utf8Bytes(value) {
+  let bytes = 0;
+  for (let index = 0; index < value.length; ) {
+    const unit = utf8UnitAt(value, index);
+    bytes += unit.bytes;
+    index += unit.codeUnits;
+  }
+  return bytes;
+}
+function measureJsonBytes(value) {
+  const state = {
+    remainingNodes: MAX_MEASUREMENT_NODES,
+    seen: /* @__PURE__ */ new WeakSet(),
+    failureReason: null
+  };
+  try {
+    const bytes = measureJsonValue(value, state, "top", 0);
+    return bytes === null ? {
+      bytes: null,
+      reason: state.failureReason ?? "payload_measurement_bounded"
+    } : { bytes, reason: null };
+  } catch {
+    return { bytes: null, reason: "payload_measurement_bounded" };
+  }
+}
+function measureJsonValue(value, state, position, depth) {
+  if (state.remainingNodes <= 0 || depth > MAX_MEASUREMENT_DEPTH) {
+    return failJsonMeasurement(state, "payload_measurement_bounded");
+  }
+  state.remainingNodes -= 1;
+  if (value === null) return 4;
+  if (typeof value === "string") return jsonStringBytes(value);
+  if (typeof value === "boolean") return value ? 4 : 5;
+  if (typeof value === "number") {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? null : serialized.length;
+  }
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+    return position === "array" ? 4 : failJsonMeasurement(state, "payload_not_serializable");
+  }
+  if (typeof value === "bigint") {
+    return failJsonMeasurement(state, "payload_not_serializable");
+  }
+  if (typeof value !== "object") {
+    return failJsonMeasurement(state, "payload_not_serializable");
+  }
+  if (value instanceof Date) {
+    if (!hasCanonicalDateSerialization(value)) {
+      return failJsonMeasurement(state, "payload_measurement_bounded");
+    }
+    try {
+      const epoch = Date.prototype.getTime.call(value);
+      return Number.isFinite(epoch) ? jsonStringBytes(Date.prototype.toISOString.call(value)) : 4;
+    } catch {
+      return failJsonMeasurement(state, "payload_not_serializable");
+    }
+  }
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    return failJsonMeasurement(state, "payload_measurement_bounded");
+  }
+  if (state.seen.has(value)) {
+    return failJsonMeasurement(state, "payload_not_serializable");
+  }
+  state.seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getPrototypeOf(value) !== Array.prototype) {
+        return failJsonMeasurement(state, "payload_measurement_bounded");
+      }
+      const toJson2 = Object.getOwnPropertyDescriptor(value, "toJSON");
+      if (toJson2 && ("get" in toJson2 || typeof toJson2.value === "function")) {
+        return failJsonMeasurement(state, "payload_measurement_bounded");
+      }
+      if (value.length > state.remainingNodes) {
+        return failJsonMeasurement(state, "payload_measurement_bounded");
+      }
+      let bytes2 = 2;
+      for (let index = 0; index < value.length; index += 1) {
+        if (index > 0) bytes2 += 1;
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor && !("value" in descriptor)) {
+          return failJsonMeasurement(state, "payload_measurement_bounded");
+        }
+        const entry = descriptor && "value" in descriptor ? descriptor.value : void 0;
+        const measured = measureJsonValue(entry, state, "array", depth + 1);
+        if (measured === null) return null;
+        bytes2 += measured;
+      }
+      return bytes2;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      return failJsonMeasurement(state, "payload_measurement_bounded");
+    }
+    const toJson = Object.getOwnPropertyDescriptor(value, "toJSON");
+    if (toJson && ("get" in toJson || typeof toJson.value === "function")) {
+      return failJsonMeasurement(state, "payload_measurement_bounded");
+    }
+    let bytes = 2;
+    let fields = 0;
+    try {
+      for (const key in value) {
+        if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+        if (state.remainingNodes <= 0) {
+          return failJsonMeasurement(state, "payload_measurement_bounded");
+        }
+        state.remainingNodes -= 1;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor)) {
+          return failJsonMeasurement(state, "payload_measurement_bounded");
+        }
+        const entry = descriptor.value;
+        if (typeof entry === "undefined" || typeof entry === "function" || typeof entry === "symbol") {
+          continue;
+        }
+        const measured = measureJsonValue(entry, state, "object", depth + 1);
+        if (measured === null) return null;
+        if (fields > 0) bytes += 1;
+        bytes += jsonStringBytes(key) + 1 + measured;
+        fields += 1;
+      }
+    } catch {
+      return null;
+    }
+    return bytes;
+  } finally {
+    state.seen.delete(value);
+  }
+}
+function hasCanonicalDateSerialization(value) {
+  try {
+    if (Object.getPrototypeOf(value) !== Date.prototype) return false;
+    return Object.getOwnPropertyDescriptor(value, "toJSON") === void 0;
+  } catch {
+    return false;
+  }
+}
+function failJsonMeasurement(state, reason) {
+  state.failureReason ??= reason;
+  return null;
+}
+function jsonStringBytes(value) {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || code === 8 || code === 9 || code === 10 || code === 12 || code === 13) {
+      bytes += 2;
+    } else if (code <= 31) {
+      bytes += 6;
+    } else if (code <= 127) {
+      bytes += 1;
+    } else if (code <= 2047) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index += 1;
+      } else {
+        bytes += 6;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      bytes += 6;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function serializeForBoundary(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return {
+      value: serialized === void 0 ? "null" : serialized,
+      serializable: serialized !== void 0
+    };
+  } catch {
+    return {
+      value: JSON.stringify("[unserializable event payload omitted]"),
+      serializable: false
+    };
+  }
+}
+function stringifyForBoundary(value) {
+  return serializeForBoundary(value).value;
+}
+function isPlainRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/workspace-control-event.ts
+var WORKSPACE_CONTROL_REASON_MAX_BYTES = 8 * 1024;
+var WORKSPACE_CONTROL_ACTOR_MAX_BYTES = 1024;
+var WORKSPACE_CONTROL_EVENT_MAX_BYTES = 16 * 1024;
+function workspaceControlUtf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function boundWorkspaceControlEvent(event, options = {}) {
+  const existingFields = new Map(
+    (event.truncation?.fields ?? []).map((field) => [field.field, field])
+  );
+  const reason = event.reason === null ? null : boundWorkspaceControlText(event.reason, WORKSPACE_CONTROL_REASON_MAX_BYTES);
+  const actor = boundWorkspaceControlText(event.actor, WORKSPACE_CONTROL_ACTOR_MAX_BYTES);
+  const reasonBytes = reason === null ? 0 : workspaceControlUtf8Bytes(reason);
+  const actorBytes = workspaceControlUtf8Bytes(actor);
+  const reasonOriginalBytes = event.reason === null ? null : Math.max(
+    workspaceControlUtf8Bytes(event.reason),
+    normalizedWorkspaceControlOriginalBytes(options.reasonOriginalBytes),
+    existingFields.get("reason")?.originalBytes ?? 0
+  );
+  const actorOriginalBytes = Math.max(
+    workspaceControlUtf8Bytes(event.actor),
+    normalizedWorkspaceControlOriginalBytes(options.actorOriginalBytes),
+    existingFields.get("actor")?.originalBytes ?? 0
+  );
+  const fields = [];
+  if (reasonOriginalBytes !== null && reasonOriginalBytes > reasonBytes) {
+    fields.push({
+      field: "reason",
+      originalBytes: reasonOriginalBytes,
+      deliveredBytes: reasonBytes,
+      omittedBytes: reasonOriginalBytes - reasonBytes
+    });
+  }
+  if (actorOriginalBytes > actorBytes) {
+    fields.push({
+      field: "actor",
+      originalBytes: actorOriginalBytes,
+      deliveredBytes: actorBytes,
+      omittedBytes: actorOriginalBytes - actorBytes
+    });
+  }
+  if (fields.length === 0 && event.truncation == null) {
+    if (sessionEventJsonBytes(event) > WORKSPACE_CONTROL_EVENT_MAX_BYTES) {
+      throw new RangeError("Workspace control event exceeds its bounded envelope");
+    }
+    return event;
+  }
+  const truncation = {
+    truncated: true,
+    surface: event.truncation?.surface ?? options.surface ?? "durable_control",
+    deliveredBytes: 0,
+    fields,
+    fullEvidence: { available: false, reason: "not_retained" }
+  };
+  const bounded = {
+    ...event,
+    reason,
+    actor,
+    truncation
+  };
+  settleWorkspaceControlDeliveredBytes(bounded, truncation);
+  const deliveredBytes = sessionEventJsonBytes(bounded);
+  if (deliveredBytes > WORKSPACE_CONTROL_EVENT_MAX_BYTES) {
+    throw new RangeError(
+      `Bounded workspace control event exceeds its final envelope (${deliveredBytes} > ${WORKSPACE_CONTROL_EVENT_MAX_BYTES} bytes)`
+    );
+  }
+  return bounded;
+}
+function boundWorkspaceControlText(value, maxBytes) {
+  const encoder2 = new TextEncoder();
+  const decoder = new TextDecoder();
+  const bytes = encoder2.encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  const marker = "\u2026[truncated]";
+  const prefixBudget = Math.max(0, maxBytes - encoder2.encode(marker).byteLength);
+  let prefixEnd = Math.min(prefixBudget, bytes.byteLength);
+  while (prefixEnd > 0 && prefixEnd < bytes.byteLength && (bytes[prefixEnd] & 192) === 128) {
+    prefixEnd -= 1;
+  }
+  return `${decoder.decode(bytes.subarray(0, prefixEnd))}${marker}`;
+}
+function normalizedWorkspaceControlOriginalBytes(value) {
+  return value === null || value === void 0 || !Number.isFinite(value) ? 0 : Math.max(0, Math.floor(value));
+}
+function settleWorkspaceControlDeliveredBytes(event, truncation) {
+  for (let attempt = 0; attempt < 16; attempt += 1) {
+    const deliveredBytes2 = sessionEventJsonBytes(event);
+    if (truncation.deliveredBytes === deliveredBytes2) return;
+    truncation.deliveredBytes = deliveredBytes2;
+  }
+  const deliveredBytes = sessionEventJsonBytes(event);
+  if (truncation.deliveredBytes !== deliveredBytes) {
+    throw new RangeError("Workspace control event byte accounting did not converge");
+  }
+}
+
+export {
+  SESSION_EVENT_PAYLOAD_MAX_BYTES,
+  TOOL_CALL_OUTPUT_EVENT_MAX_BYTES,
+  sessionEventJsonBytes,
+  measureSessionEventJson,
+  approximateSessionEventTokens,
+  sessionEventMediaPreview,
+  sessionEventMediaPreviewFromDataUrl,
+  sessionEventPayloadTruncation,
+  boundSessionEventPayload,
+  boundSessionEventPayloadForWrite,
+  WORKSPACE_CONTROL_REASON_MAX_BYTES,
+  WORKSPACE_CONTROL_ACTOR_MAX_BYTES,
+  WORKSPACE_CONTROL_EVENT_MAX_BYTES,
+  workspaceControlUtf8Bytes,
+  boundWorkspaceControlEvent
+};
+//# sourceMappingURL=chunk-4YDDHSO2.js.map