@peasant-labs/schema 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -7,3 +7,16 @@ export declare function isProjectHash(value: unknown): value is ProjectHash;
 export declare function validateProjectHash(value: unknown): asserts value is ProjectHash;
 export declare function newProjectHash(raw: string): ProjectHash;
 export type PushContractVersion = import("./internal/generated/contract/zod.gen.js").ContractVersion;
+export interface RawJsonPathPolicy {
+    maxDocumentBytes?: number;
+    maxDocumentDepth?: number;
+    opaqueMetadataPointers?: readonly string[];
+}
+export declare function scanRawJsonText(text: string, policy?: RawJsonPathPolicy): void;
+export declare function parseSessionDetailPayloadValue(value: unknown): import("./internal/generated/contract/zod.gen.js").SessionDetailPayload;
+export declare function parseSessionDetailPayloadText(text: string): import("./internal/generated/contract/zod.gen.js").SessionDetailPayload;
+export declare function parseTranscriptContentText(text: string): import("./internal/generated/contract/zod.gen.js").TranscriptContent;
+export declare function parseServerMessageRaw(text: string): import("./internal/generated/contract/zod.gen.js").ServerMessage;
+type Detail = import("./internal/generated/contract/zod.gen.js").SessionDetailPayload;
+export declare function parseNativeMetadataRecordsValue(value: unknown, targets?: unknown): NonNullable<Detail["nativeMetadata"]>;
+export declare function parseNativeMetadataRecordsText(text: string, targets?: unknown): NonNullable<Detail["nativeMetadata"]>;

package/dist/index.js

@@ -2,7 +2,7 @@ export * from "./internal/generated/public-contract.gen.js";
 export * from "./internal/generated/enums.gen.js";
 export * from "./internal/generated/content-capabilities.gen.js";
 export * from "./internal/generated/versions.gen.js";
-import { zProjectHash } from "./internal/generated/contract/zod.gen.js";
+import { zNativeMetadataRecord, zTurnDetail, zProjectHash, zServerMessage, zSessionDetailPayload, zTranscriptContent } from "./internal/generated/contract/zod.gen.js";
 function assertProjectHash(value, operation) {
     if (!isProjectHash(value)) {
         const rendered = renderProjectHashInput(value);
@@ -35,3 +35,424 @@ export function newProjectHash(raw) {
     assertProjectHash(raw, "newProjectHash");
     return raw;
 }
+export function scanRawJsonText(text, policy = {}) {
+    scanRawJson(text, policy);
+}
+function scanRawJson(text, policy) {
+    if (policy.maxDocumentBytes !== undefined && new TextEncoder().encode(text).length > policy.maxDocumentBytes) {
+        throw new TypeError("Raw JSON validation failed at @peasant-labs/schema scanRawJsonText during pre-decode scanning: the document exceeds the configured byte limit; parsing it would cross the caller's safety boundary; reduce the document before retrying.");
+    }
+    const scanner = new RawJsonScanner(text, policy);
+    scanner.scan();
+    return scanner;
+}
+export function parseSessionDetailPayloadValue(value) {
+    rejectExplicitNullEvidence(value);
+    const payload = zSessionDetailPayload.parse(value);
+    validateSessionDetail(payload);
+    return payload;
+}
+export function parseSessionDetailPayloadText(text) {
+    scanRawJsonText(text, { maxDocumentBytes: 8 << 20, maxDocumentDepth: 64, opaqueMetadataPointers: ["/nativeMetadata/*/data"] });
+    return parseSessionDetailPayloadValue(JSON.parse(text));
+}
+export function parseTranscriptContentText(text) {
+    scanRawJsonText(text, { maxDocumentBytes: 8 << 20, maxDocumentDepth: 64, opaqueMetadataPointers: ["/sessionDetail/nativeMetadata/*/data"] });
+    const raw = JSON.parse(text);
+    if (isRecord(raw))
+        rejectExplicitNullEvidence(raw.sessionDetail);
+    const content = zTranscriptContent.parse(raw);
+    if (content.sessionDetail === undefined || content.sessionDetail === null)
+        failSemantic("sessionDetail is required");
+    parseSessionDetailPayloadValue(content.sessionDetail);
+    return content;
+}
+export function parseServerMessageRaw(text) {
+    // Dispatch from the syntax scan, not a lossy full-document JSON.parse. The
+    // type member may follow data, so a second selected scan precedes decoding.
+    const dispatch = scanRawJson(text, { maxDocumentBytes: 8 << 20, maxDocumentDepth: 64 });
+    if (dispatch.rootMessageType === "session_detail") {
+        scanRawJsonText(text, { maxDocumentBytes: 8 << 20, maxDocumentDepth: 64, opaqueMetadataPointers: ["/data/nativeMetadata/*/data"] });
+    }
+    const value = JSON.parse(text);
+    if (isRecord(value) && value.type === "session_detail")
+        rejectExplicitNullEvidence(value.data);
+    const message = zServerMessage.parse(value);
+    if (message.type === "session_detail") {
+        parseSessionDetailPayloadValue(message.data);
+    }
+    return message;
+}
+class RawJsonScanner {
+    text;
+    policy;
+    position = 0;
+    metadataBytes = 0;
+    rootMessageType;
+    constructor(text, policy) {
+        this.text = text;
+        this.policy = policy;
+    }
+    scan() { this.space(); this.value("", 1, 0); this.space(); if (this.position !== this.text.length)
+        this.fail("trailing content"); }
+    value(path, depth, metadataDepth) {
+        if (metadataDepth === 0 && (this.policy.opaqueMetadataPointers ?? []).some(pattern => pointerMatches(pattern, path)))
+            metadataDepth = 1;
+        if (this.policy.maxDocumentDepth !== undefined && depth > this.policy.maxDocumentDepth)
+            this.fail("document depth exceeds configured limit");
+        if (metadataDepth > 32)
+            this.fail("metadata depth exceeds 32");
+        this.space();
+        const start = this.position;
+        this.valueBody(path, depth, metadataDepth);
+        if (metadataDepth === 1) {
+            const bytes = new TextEncoder().encode(this.text.slice(start, this.position)).length;
+            this.metadataBytes += bytes;
+            if (bytes > 65536 || this.metadataBytes > 1048576)
+                this.fail("metadata data exceeds its byte budget (64 KiB per value, 1 MiB aggregate)");
+        }
+    }
+    valueBody(path, depth, metadataDepth) {
+        const opaque = metadataDepth > 0;
+        this.space();
+        const c = this.text[this.position];
+        if (c === "{")
+            return this.object(path, depth, metadataDepth);
+        if (c === "[")
+            return this.array(path, depth, metadataDepth);
+        if (c === '"') {
+            const value = this.string();
+            if (path === "/type")
+                this.rootMessageType = value;
+            if (opaque && new TextEncoder().encode(value).length > 16384)
+                this.fail("metadata string exceeds 16 KiB");
+            return;
+        }
+        if (c === "t")
+            return this.literal("true");
+        if (c === "f")
+            return this.literal("false");
+        if (c === "n")
+            return this.literal("null");
+        const match = this.text.slice(this.position).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+        if (match === null)
+            this.fail("invalid value");
+        this.position += match[0].length;
+        if (opaque) {
+            const n = Number(match[0]);
+            if (n === 0 && !/^-?0(?:\.0*)?(?:[eE][+-]?\d+)?$/.test(match[0]))
+                this.fail("metadata number underflows to zero");
+            if (!Number.isFinite(n) || (Number.isInteger(n) && !Number.isSafeInteger(n)))
+                this.fail("metadata number is outside the finite JS-safe domain");
+        }
+    }
+    object(path, depth, metadataDepth) {
+        this.position++;
+        this.space();
+        const keys = new Set();
+        while (this.text[this.position] !== "}") {
+            const key = this.string();
+            if (metadataDepth > 0 && new TextEncoder().encode(key).length > 512)
+                this.fail("metadata key exceeds 512 bytes");
+            if (keys.has(key))
+                this.fail(`duplicate object key ${JSON.stringify(key)}`);
+            keys.add(key);
+            if (metadataDepth > 0 && keys.size > 256)
+                this.fail("metadata object exceeds 256 members");
+            this.space();
+            this.expect(":");
+            const child = `${path}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+            this.value(child, depth + 1, metadataDepth > 0 ? metadataDepth + 1 : 0);
+            this.space();
+            if (this.text[this.position] !== ",")
+                break;
+            this.position++;
+            this.space();
+            if (this.text[this.position] === "}")
+                this.fail("trailing comma");
+        }
+        this.expect("}");
+    }
+    array(path, depth, metadataDepth) {
+        this.position++;
+        this.space();
+        let count = 0;
+        while (this.text[this.position] !== "]") {
+            if (metadataDepth > 0 && count >= 4096)
+                this.fail("metadata array exceeds 4096 elements");
+            this.value(`${path}/${count++}`, depth + 1, metadataDepth > 0 ? metadataDepth + 1 : 0);
+            this.space();
+            if (this.text[this.position] !== ",")
+                break;
+            this.position++;
+            this.space();
+            if (this.text[this.position] === "]")
+                this.fail("trailing comma");
+        }
+        this.expect("]");
+    }
+    string() { const start = this.position; this.expect('"'); for (;;) {
+        const c = this.text[this.position++];
+        if (c === undefined || c === "\n" || c === "\r")
+            this.fail("unterminated string");
+        if (c === '"')
+            break;
+        if (c === "\\") {
+            const escaped = this.text[this.position++];
+            if (escaped === "u") {
+                const hex = this.text.slice(this.position, this.position + 4);
+                if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                    this.fail("invalid Unicode escape");
+                const unit = Number.parseInt(hex, 16);
+                this.position += 4;
+                if (unit >= 0xd800 && unit <= 0xdbff) {
+                    if (this.text.slice(this.position, this.position + 2) !== "\\u")
+                        this.fail("unpaired Unicode surrogate");
+                    const lowHex = this.text.slice(this.position + 2, this.position + 6);
+                    if (!/^[0-9a-fA-F]{4}$/.test(lowHex) || Number.parseInt(lowHex, 16) < 0xdc00 || Number.parseInt(lowHex, 16) > 0xdfff)
+                        this.fail("invalid Unicode surrogate pair");
+                    this.position += 6;
+                }
+                else if (unit >= 0xdc00 && unit <= 0xdfff)
+                    this.fail("unpaired Unicode surrogate");
+            }
+            else if (!'"\\/bfnrt'.includes(escaped ?? ""))
+                this.fail("invalid escape");
+        }
+        else {
+            const unit = c.charCodeAt(0);
+            if (unit < 0x20)
+                this.fail("unescaped control character");
+            if (unit >= 0xd800 && unit <= 0xdbff) {
+                const low = this.text.charCodeAt(this.position);
+                if (low < 0xdc00 || low > 0xdfff)
+                    this.fail("unpaired Unicode surrogate");
+                this.position++;
+            }
+            else if (unit >= 0xdc00 && unit <= 0xdfff)
+                this.fail("unpaired Unicode surrogate");
+        }
+    } return JSON.parse(this.text.slice(start, this.position)); }
+    literal(value) { if (!this.text.startsWith(value, this.position))
+        this.fail("invalid literal"); this.position += value.length; }
+    expect(value) { if (this.text[this.position] !== value)
+        this.fail(`expected ${value}`); this.position++; }
+    space() { while (this.text[this.position] === " " || this.text[this.position] === "\t" || this.text[this.position] === "\n" || this.text[this.position] === "\r")
+        this.position++; }
+    fail(reason) { throw new TypeError(`Raw JSON validation failed at @peasant-labs/schema scanRawJsonText during pre-decode scanning near character ${this.position}: ${reason}; JSON.parse would otherwise lose or misinterpret evidence; correct the raw JSON and retry.`); }
+}
+function pointerMatches(pattern, path) { const expected = pattern.split("/"); const actual = path.split("/"); return expected.length === actual.length && expected.every((part, index) => part === "*" || part === actual[index]); }
+function validateSessionDetail(payload) {
+    const turns = validateTurnEvidence(payload.turns ?? []);
+    if ((payload.nativeMetadata?.length ?? 0) > 0 && String(payload.harness) !== "pi")
+        failSemantic("Pi native metadata requires harness pi");
+    validateMetadataRecords(payload.nativeMetadata ?? [], turns);
+}
+// Producers can validate metadata before attaching it to a harness envelope.
+// The full detail parsers reuse this same record and target validation.
+export function parseNativeMetadataRecordsValue(value, targets = []) {
+    rejectExplicitNullEvidence({ nativeMetadata: value, turns: targets });
+    const turns = zTurnDetail.array().parse(targets);
+    const records = zNativeMetadataRecord.array().parse(value);
+    validateMetadataRecords(records, validateTurnEvidence(turns));
+    return records;
+}
+export function parseNativeMetadataRecordsText(text, targets = []) {
+    scanRawJsonText(text, { maxDocumentBytes: 8 << 20, maxDocumentDepth: 64, opaqueMetadataPointers: ["/*/data"] });
+    return parseNativeMetadataRecordsValue(JSON.parse(text), targets);
+}
+function validateTurnEvidence(targets) {
+    const owners = new Set();
+    const sources = new Set();
+    const turnIndexes = new Set();
+    const toolIds = new Set();
+    const turns = new Map();
+    for (const turn of targets) {
+        if (turn.observedModel !== undefined && (turn.role !== "assistant" || !validUnicode(turn.observedModel)))
+            failSemantic("observedModel requires valid Unicode and an assistant role");
+        if (turnIndexes.has(turn.index))
+            failSemantic("duplicate turn index makes metadata attachment ambiguous");
+        turnIndexes.add(turn.index);
+        turns.set(turn.index, turn);
+        if (turn.sourceEntryRef !== undefined && !validOptionalRef(turn.sourceEntryRef))
+            failSemantic("turn source reference is invalid or exceeds 96 bytes");
+        if (turn.usage != null) {
+            if (!((turn.role === "assistant" && turn.usage.scope === "assistant") || (turn.role === "system" && turn.usage.scope === "summary")))
+                failSemantic("turn role and usage scope disagree");
+            if (!turn.sourceEntryRef || turn.usage.sourceEntryRef !== turn.sourceEntryRef)
+                failSemantic("turn usage source reference disagrees");
+            validateUsage(turn.usage, owners, sources);
+        }
+        for (const tool of turn.toolCalls ?? []) {
+            if (!validOptionalRef(tool.id))
+                failSemantic("tool id reference is invalid or exceeds 96 bytes");
+            if (tool.id && toolIds.has(tool.id))
+                failSemantic("duplicate tool call id makes metadata attachment ambiguous");
+            if (tool.id)
+                toolIds.add(tool.id);
+            if (tool.callEntryRef !== undefined && !validOptionalRef(tool.callEntryRef))
+                failSemantic("tool call reference is invalid or exceeds 96 bytes");
+            if (tool.resultEntryRef !== undefined && !validOptionalRef(tool.resultEntryRef))
+                failSemantic("tool result reference is invalid or exceeds 96 bytes");
+            if (tool.usage != null) {
+                if (tool.usage.scope !== "tool" || !tool.resultEntryRef || tool.usage.sourceEntryRef !== tool.resultEntryRef)
+                    failSemantic("tool usage attribution disagrees");
+                validateUsage(tool.usage, owners, sources);
+            }
+        }
+    }
+    return turns;
+}
+function validateMetadataRecords(records, turns) {
+    const ids = new Set();
+    let metadataBytes = 0;
+    if (records.length > 256)
+        failSemantic("native metadata record count exceeds 256");
+    for (const metadata of records) {
+        if (!validRef(metadata.id) || !validRef(metadata.source.entryRef) || ids.has(metadata.id))
+            failSemantic("metadata reference is invalid or duplicated");
+        ids.add(metadata.id);
+        if (metadata.customType !== undefined && (!validUnicode(metadata.customType) || new TextEncoder().encode(metadata.customType).length > 128))
+            failSemantic("customType is invalid Unicode or exceeds 128 bytes");
+        validateMetadataValue(metadata.data, 1);
+        const encoded = new TextEncoder().encode(JSON.stringify(metadata.data)).length;
+        metadataBytes += encoded;
+        if (encoded > 65536 || metadataBytes > 1048576)
+            failSemantic("metadata data exceeds its byte budget");
+        const attachment = metadata.attachment;
+        const target = attachment?.turnIndex == null ? undefined : turns.get(attachment.turnIndex);
+        if (attachment?.toolCallId !== undefined && !validRef(attachment.toolCallId))
+            failSemantic("attachment tool reference is invalid or exceeds 96 bytes");
+        switch (metadata.kind) {
+            case "pi.custom.data":
+                if (metadata.source.sourceType !== "pi.custom" || metadata.source.messageRole !== undefined || attachment !== undefined || !metadata.customType)
+                    failSemantic("custom data metadata matrix disagrees");
+                break;
+            case "pi.custommessage.details":
+                if (metadata.source.sourceType !== "pi.custom_message" || metadata.source.messageRole !== undefined || attachment?.turnIndex === undefined || attachment.toolCallId !== undefined || !metadata.customType || target?.role !== "system" || target.sourceEntryRef !== metadata.source.entryRef)
+                    failSemantic("custom message metadata matrix disagrees");
+                break;
+            case "pi.toolresult.details": {
+                const tools = target?.toolCalls?.filter(tool => tool.id === attachment?.toolCallId) ?? [];
+                const tool = tools[0];
+                if (metadata.source.sourceType !== "pi.message" || metadata.source.messageRole !== "toolResult" || attachment?.turnIndex === undefined || !attachment.toolCallId || metadata.customType !== undefined || tools.length !== 1 || tool?.resultEntryRef !== metadata.source.entryRef || (tool.usage != null && tool.usage.sourceEntryRef !== metadata.source.entryRef))
+                    failSemantic("tool result metadata matrix disagrees");
+                break;
+            }
+            case "pi.compaction.details":
+            case "pi.branchsummary.details": {
+                const source = metadata.kind === "pi.compaction.details" ? "pi.compaction" : "pi.branch_summary";
+                if (metadata.source.sourceType !== source || metadata.source.messageRole !== undefined || attachment?.turnIndex === undefined || attachment.toolCallId !== undefined || metadata.customType !== undefined || target?.role !== "system" || target.sourceEntryRef !== metadata.source.entryRef || target.usage?.scope !== "summary" || target.usage.sourceEntryRef !== metadata.source.entryRef)
+                    failSemantic("summary metadata matrix disagrees");
+                break;
+            }
+            default: failSemantic("metadata kind is outside its closed set");
+        }
+    }
+}
+function validateUsage(usage, owners, sources) {
+    if (!validRef(usage.ownerId) || !validRef(usage.sourceEntryRef) || owners.has(usage.ownerId) || sources.has(usage.sourceEntryRef))
+        failSemantic("usage owner/source reference is invalid or duplicated");
+    owners.add(usage.ownerId);
+    sources.add(usage.sourceEntryRef);
+    const tokens = usage.tokens;
+    const base = tokens == null ? [] : [tokens.input, tokens.output, tokens.cacheRead, tokens.cacheWrite, tokens.totalTokens];
+    const present = base.filter(v => v !== undefined && v !== null).length;
+    for (const value of tokens == null ? [] : [...base, tokens.reasoning, tokens.cacheWrite1h])
+        if (value != null && (!Number.isSafeInteger(value) || value < 0))
+            failSemantic("token is outside JS-safe nonnegative integers");
+    const expected = present === 5 ? "complete" : present === 0 ? "unknown" : "partial";
+    if (usage.completeness !== expected)
+        failSemantic("usage completeness disagrees with token presence");
+    if (tokens?.reasoning != null && tokens.output != null && tokens.reasoning > tokens.output)
+        failSemantic("reasoning exceeds output");
+    if (tokens?.cacheWrite1h != null && tokens.cacheWrite != null && tokens.cacheWrite1h > tokens.cacheWrite)
+        failSemantic("cacheWrite1h exceeds cacheWrite");
+    if (present === 5 && tokens && tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite !== tokens.totalTokens)
+        failSemantic("totalTokens disagrees with base sum");
+    if (usage.cost != null) {
+        if (usage.cost.source !== "recorded_harness_estimate")
+            failSemantic("recorded cost source is invalid");
+        for (const value of [usage.cost.input, usage.cost.output, usage.cost.cacheRead, usage.cost.cacheWrite, usage.cost.total])
+            if (value != null && (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value) || !Number.isFinite(Number(value)) || Number(value) < 0))
+                failSemantic("recorded cost is not a finite nonnegative JSON number");
+    }
+}
+function validRef(value) { return value !== undefined && value.length > 0 && validOptionalRef(value); }
+function validOptionalRef(value) { return validUnicode(value) && new TextEncoder().encode(value).length <= 96; }
+function validUnicode(value) {
+    for (let i = 0; i < value.length; i++) {
+        const unit = value.charCodeAt(i);
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            const low = value.charCodeAt(++i);
+            if (!(low >= 0xdc00 && low <= 0xdfff))
+                return false;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff)
+            return false;
+    }
+    return true;
+}
+function validateMetadataValue(value, depth) {
+    if (depth > 32)
+        failSemantic("metadata data exceeds depth 32");
+    if (typeof value === "string" && (!validUnicode(value) || new TextEncoder().encode(value).length > 16384))
+        failSemantic("metadata string is invalid Unicode or exceeds 16 KiB");
+    if (typeof value === "number" && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))
+        failSemantic("metadata number is outside the finite JS-safe domain");
+    if (value !== null && !["string", "number", "boolean", "object"].includes(typeof value))
+        failSemantic("metadata data is not a JSON value");
+    if (Array.isArray(value)) {
+        if (value.length > 4096)
+            failSemantic("metadata array exceeds 4096 elements");
+        for (const item of value)
+            validateMetadataValue(item, depth + 1);
+    }
+    else if (isRecord(value)) {
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+            failSemantic("metadata data must use plain JSON objects");
+        const entries = Object.entries(value);
+        if (entries.length > 256)
+            failSemantic("metadata object exceeds 256 members");
+        for (const [key, item] of entries) {
+            if (!validUnicode(key) || new TextEncoder().encode(key).length > 512)
+                failSemantic("metadata key is invalid Unicode or exceeds 512 bytes");
+            validateMetadataValue(item, depth + 1);
+        }
+    }
+}
+function isRecord(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
+function rejectExplicitNullEvidence(value) {
+    if (!isRecord(value))
+        return;
+    for (const turn of Array.isArray(value.turns) ? value.turns : []) {
+        if (!isRecord(turn))
+            continue;
+        const tools = Array.isArray(turn.toolCalls) ? turn.toolCalls : [];
+        for (const usage of [turn.usage, ...tools.map(tool => isRecord(tool) ? tool.usage : undefined)]) {
+            if (!isRecord(usage) || !isRecord(usage.tokens))
+                continue;
+            for (const [name, token] of Object.entries(usage.tokens))
+                if (token === null)
+                    failSemantic(`token ${name} is explicitly null`);
+        }
+    }
+    for (const record of Array.isArray(value.nativeMetadata) ? value.nativeMetadata : []) {
+        if (!isRecord(record))
+            continue;
+        for (const name of ["id", "kind", "source", "data"])
+            if (!(name in record) || record[name] === null)
+                failSemantic(`metadata required field ${name} is missing or null`);
+        if (record.attachment === null)
+            failSemantic("metadata attachment is explicitly null");
+        if (isRecord(record.attachment)) {
+            if (record.attachment.turnIndex === null)
+                failSemantic("metadata attachment.turnIndex is explicitly null");
+            if ("toolCallId" in record.attachment && record.kind !== "pi.toolresult.details")
+                failSemantic("metadata attachment.toolCallId is forbidden for this kind");
+        }
+        if (isRecord(record.source) && "messageRole" in record.source && record.kind !== "pi.toolresult.details")
+            failSemantic("metadata source.messageRole is forbidden for this kind");
+    }
+}
+function failSemantic(reason) { throw new TypeError(`Session detail validation failed at @peasant-labs/schema public parser during semantic validation: ${reason}; consumers cannot safely attribute transcript evidence; correct the payload and retry.`); }

package/dist/internal/generated/content-capabilities.gen.d.ts

@@ -8,6 +8,8 @@
  * discovered list down to the tokens they understand without stringly typing.
  */
 export declare const KnownContentCapability: Readonly<{
+    readonly DetailedUsageV1: "detailed_usage_v1";
+    readonly NativeMetadataV1: "native_metadata_v1";
     readonly ObservedModelV1: "observed_model_v1";
 }>;
 export type KnownContentCapability = (typeof KnownContentCapability)[keyof typeof KnownContentCapability];

package/dist/internal/generated/content-capabilities.gen.js

@@ -9,9 +9,11 @@
  * discovered list down to the tokens they understand without stringly typing.
  */
 export const KnownContentCapability = Object.freeze({
+    DetailedUsageV1: "detailed_usage_v1",
+    NativeMetadataV1: "native_metadata_v1",
     ObservedModelV1: "observed_model_v1",
 });
-export const AllContentCapabilities = Object.freeze([KnownContentCapability.ObservedModelV1]);
+export const AllContentCapabilities = Object.freeze([KnownContentCapability.DetailedUsageV1, KnownContentCapability.NativeMetadataV1, KnownContentCapability.ObservedModelV1]);
 export function isContentCapability(value) {
     return typeof value === "string" && AllContentCapabilities.includes(value);
 }