import { isProxy } from 'node:util/types'; import { StreamLimitExceededError } from '@librechat/agents'; import { FILE_FILTER_FIELDS, HITL_MESSAGE_FILTER_FIELDS, hasActivePiiFields, hasActivePiiPatterns, } from 'librechat-data-provider'; import type { FiltersConfig, MessageFilterPiiConfig, UserSubmittedMessageFieldPath, } from 'librechat-data-provider'; import type { AgentContentInput, AssistantActionContentInput, AssistantContentInput, FileContentInput, MemoryContentInput, SkillContentInput, StoredMessageContentInput, } from '../protection/adapters/submissions'; import type { ContentTraversalScope, VisitNestedStringsBudget, } from '../protection/adapters/nested'; import type { JsonPointer, TextContentFragment } from '../protection/types'; import type { ExternalChatMessage } from '../protection/adapters/messages'; import type { LocatorTraversalReporter } from '../protection/diagnostics'; import type { ConfiguredContentInspector } from '../protection/runtime'; import type { CanonicalFileInspectionFile } from '../protection/files'; import { CONTENT_TRAVERSAL_MAX_DEPTH, CONTENT_TRAVERSAL_MAX_NODES, CONTENT_MATERIALIZATION_MAX_CHARACTERS, getBoundedOwnEnumerableEntries, getContentTraversalFragments, getContentTraversalScopes, isContentTraversalProtected, isContentTraversalLimitError, isNestedMessageTraversalProtected, reserveContentMaterialization, } from '../protection/adapters/nested'; import { allowHydratedFileReferences, assertHydratedFileInspectable, hasActiveFilePolicy, getBlockedOpaqueFileField, getBlockedUninspectableFileField, omitResolvedCanonicalFileLocators, UninspectableFileError, } from '../protection/files'; import { extractAgentContent, extractAssistantActionContent, extractAssistantContent, extractFileContent, extractMemoryContent, extractSkillContent, extractStoredMessageContent, } from '../protection/adapters/submissions'; import { MAX_USER_SUBMITTED_PATHS, getCapturedUserSubmittedPathMetadata, getSafeUserSubmittedPathSegments, getUserSubmittedMessageFieldPathState, getUserSubmittedPathState, } from '../protection/provenance'; import { extractMessageContent, snapshotExternalMessages } from '../protection/adapters/messages'; import { ContentTraversalLimitError } from '../protection/adapters/nested'; import { ContentFilterError, isContentFilterError } from './contentFilter'; import { createConfiguredContentInspector } from '../protection/runtime'; import { aggregateAuditFindingsSync } from '../protection/audit'; export type ModelBoundProviderAttribution = 'user' | 'model' | 'tool' | 'synthetic'; export interface ModelBoundProviderProvenancePart { readonly attribution: ModelBoundProviderAttribution; readonly sourceMessageId?: string; readonly sourceContentPartIndices?: readonly number[]; } export interface ModelBoundProviderProvenance { readonly version: 1; readonly parts: readonly ModelBoundProviderProvenancePart[]; } export type ModelBoundProviderMessage = ExternalChatMessage & Omit & { readonly id?: string; readonly messageId?: string; readonly text?: string; readonly additional_kwargs?: { readonly injected?: boolean; readonly isMeta?: boolean; readonly source?: string; readonly sourceMessageId?: string; readonly sourceMessageIds?: readonly string[]; readonly provenance?: ModelBoundProviderProvenance; }; readonly _getType?: () => string; }; type ModelBoundMessage = ExternalChatMessage & { readonly _getType?: () => string; }; type StoredModelBoundMessage = StoredMessageContentInput & { readonly id?: string; readonly messageId?: string; readonly isCreatedByUser?: boolean; readonly isUserSubmitted?: boolean; readonly userSubmittedPaths?: readonly string[]; readonly userSubmittedMessageFieldPaths?: readonly UserSubmittedMessageFieldPath[]; }; type SnapshottedModelBoundProviderMessage = ModelBoundProviderMessage & Pick< StoredModelBoundMessage, 'isCreatedByUser' | 'isUserSubmitted' | 'userSubmittedPaths' | 'userSubmittedMessageFieldPaths' >; type ModelBoundCanonicalFile = FileContentInput & CanonicalFileInspectionFile; type ModelBoundPolicyError = | ContentFilterError | ContentTraversalLimitError | UninspectableFileError; const LEGACY_ARTIFACT_PROJECTION_MARKER = 'Tool response is included in the next message as a Human message'; const PROVIDER_PROVENANCE_ATTRIBUTIONS = new Set([ 'user', 'model', 'tool', 'synthetic', ]); const LEGACY_SYNTHETIC_PROVIDER_SOURCES = new Set(['handoff', 'hook', 'skill', 'system']); const MAX_PROVIDER_PROVENANCE_PARTS = 256; const MAX_PROVIDER_SOURCE_PART_INDICES = 256; const MAX_PROVIDER_PROVENANCE_INDEX_REFS = 4_096; const MAX_PROVIDER_SOURCE_MESSAGE_IDS = 256; const MAX_PROVIDER_SOURCE_MESSAGE_ID_LENGTH = 512; const MAX_PROVIDER_SOURCE_CONTENT_PART_INDEX = 4_095; const MAX_PROVIDER_PROJECTION_WORK = 4_096; const MAX_PROVIDER_PROVENANCE_PARSE_WORK = MAX_PROVIDER_PROVENANCE_INDEX_REFS + MAX_PROVIDER_PROVENANCE_PARTS; const MAX_PROVIDER_STORED_STATE_WORK = MAX_PROVIDER_PROJECTION_WORK + MAX_PROVIDER_PROVENANCE_PARTS * 2; /** One root plus bounded structural bookkeeping for every valid provider part. */ const MAX_MODEL_BOUND_NESTED_TRAVERSAL_WORK = CONTENT_TRAVERSAL_MAX_NODES * 2; function getProviderPartSnapshotTraversalScopes( providerRoles: readonly (string | undefined)[], ): ContentTraversalScope[] { const scopes: ContentTraversalScope[] = [ { source: 'message', fields: ['content_part', 'attachment_reference'] }, { source: 'assembled_context', fields: ['assembled_context'] }, { source: 'file', fields: ['name', 'uri', 'content', 'extracted_text', 'transcript'] }, { source: 'tool_argument', fields: ['name', 'arguments', 'output'] }, ]; if (providerRoles.some((role) => role === 'system' || role === 'developer')) { scopes.push({ source: 'agent_instruction', fields: ['instructions'] }); } return scopes; } interface ProviderProjectionWorkBudget { remaining: number; overflowed: boolean; parent?: ProviderProjectionWorkBudget; } interface ProviderProjectionWorkBudgets { readonly projection: ProviderProjectionWorkBudget; readonly providerContent: ProviderProjectionWorkBudget; readonly partSnapshot: ProviderProjectionWorkBudget; readonly fileScan: ProviderProjectionWorkBudget; readonly provenance: ProviderProjectionWorkBudget; readonly storedState: ProviderProjectionWorkBudget; readonly nestedTraversal: VisitNestedStringsBudget; } /** * JSON structure is bounded per message. Dynamic proxy arrays retain the * shared work ceiling; their reads can execute arbitrary code. Either budget * latches failures into the enclosing projection, including subsequent batches. */ function createMessageWorkBudget( parent: ProviderProjectionWorkBudget, candidate: unknown, remaining = MAX_PROVIDER_PROJECTION_WORK, ): ProviderProjectionWorkBudget { if (isProxy(candidate)) { return parent; } let overflowed = false; return { remaining, parent, get overflowed() { return overflowed; }, set overflowed(value: boolean) { overflowed ||= value; if (value && this.parent != null) { this.parent.overflowed = true; } }, }; } function captureProviderArrayLength(candidate: readonly unknown[]): number { const length = candidate.length; if (!Number.isSafeInteger(length) || length < 0) { throw new ContentTraversalLimitError(); } return length; } function consumeProviderProjectionWork( budget: ProviderProjectionWorkBudget, requested: number, ): boolean { if (!Number.isSafeInteger(requested) || requested < 0 || requested > budget.remaining) { budget.overflowed = true; return false; } budget.remaining -= requested; return true; } function markProviderProjectionWorkOverflow(budget: ProviderProjectionWorkBudget): void { budget.overflowed = true; } /** * Compatibility bridge for @librechat/agents 3.6.9. Its summarization, * fallback, and subagent recovery paths intentionally rethrow stream-safety * errors but recover from ordinary model callback errors. A provider-bound * policy rejection is likewise non-recoverable, so wrapping it in the one * fatal class understood by that SDK keeps every execution path fail-closed. * Remove this bridge once the SDK exposes a generic fatal callback error. */ class FatalModelBoundPolicyError extends StreamLimitExceededError { public readonly code: ModelBoundPolicyError['code']; public readonly statusCode: ModelBoundPolicyError['statusCode']; public readonly body: ModelBoundPolicyError['body']; public override readonly cause: ModelBoundPolicyError; constructor(error: ModelBoundPolicyError) { super({ kind: 'delta_events', limit: 0, observed: 0 }); this.name = error.name; this.message = error.message; this.code = error.code; this.statusCode = error.statusCode; this.body = error.body; this.cause = error; Object.setPrototypeOf(this, FatalModelBoundPolicyError.prototype); } } export interface ModelBoundProviderContentInput { readonly onTraversalFailure?: LocatorTraversalReporter; readonly filters?: FiltersConfig; readonly legacyPii?: MessageFilterPiiConfig; /** Exact generated tokens from server-owned canonical user rows, never request metadata. */ readonly privateTextTokens?: ReadonlySet; readonly providerMessages: readonly ModelBoundProviderMessage[]; readonly storedMessages?: readonly (StoredModelBoundMessage | null | undefined)[]; readonly resolvedFiles?: readonly (ModelBoundCanonicalFile | null | undefined)[]; /** Canonical files actually materialized for each persisted source row. */ readonly fileIdsBySourceMessageId?: ReadonlyMap; /** A bounded upstream source/file projection was incomplete. */ readonly sourceFileProjectionOverflowed?: boolean; } type ModelBoundFileReference = { readonly file_id?: string } | null | undefined; export interface ModelBoundSourceFileInput { readonly messageFilesBySourceMessageId?: Readonly< Record >; readonly sourceMessages?: readonly ( | { readonly messageId?: string; readonly id?: string } | null | undefined )[]; readonly steerFileIdsBySourceMessageId?: ReadonlyMap< string, readonly string[] | ReadonlySet >; readonly replayHistoricalFiles: boolean; readonly historicalFiles?: | readonly (ModelBoundCanonicalFile | null | undefined)[] | ReadonlyMap; readonly processedCurrentFiles?: readonly (ModelBoundCanonicalFile | null | undefined)[]; readonly canonicalCurrentFiles?: readonly (ModelBoundCanonicalFile | null | undefined)[]; readonly initiallyOverflowed?: boolean; } export interface ModelBoundSourceFileProjection { readonly fileIdsBySourceMessageId: ReadonlyMap; readonly resolvedFiles: readonly ModelBoundCanonicalFile[]; readonly overflowed: boolean; } export interface ModelBoundHistoricalFileIdState { readonly fileIds: string[]; readonly overflowed: boolean; } /** Collects every provider-supported persisted file locator for owner hydration. */ export function collectModelBoundHistoricalFileIdState( messages: readonly (StoredMessageContentInput | null | undefined)[], ): ModelBoundHistoricalFileIdState { const fileIds = new Set(); const budget: ProviderProjectionWorkBudget = { remaining: MAX_PROVIDER_PROJECTION_WORK, overflowed: false, }; const appendFileId = (candidate: unknown): boolean => { if (!consumeProviderProjectionWork(budget, 1)) { return false; } if (typeof candidate !== 'string') { return true; } const fileId = candidate.trim(); if (fileId.length > 0) { fileIds.add(fileId); } return true; }; const appendReference = (reference: ModelBoundFileReference): boolean => appendFileId(reference?.file_id); const appendReferences = ( references: readonly ModelBoundFileReference[] | null | undefined, ): void => { try { if (!Array.isArray(references)) { return; } const referenceCount = captureProviderArrayLength(references); let index = 0; for (; index < referenceCount; index++) { if (!appendReference(references[index])) { break; } } if (index < referenceCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } }; let messageCount = 0; try { const messageLength = captureProviderArrayLength(messages); messageCount = Math.min(messageLength, MAX_PROVIDER_PROJECTION_WORK); if (messageLength > messageCount) { markProviderProjectionWorkOverflow(budget); } } catch { return { fileIds: [], overflowed: true }; } let messageIndex = 0; for (; messageIndex < messageCount && budget.remaining > 0; messageIndex++) { try { const message = messages[messageIndex]; if (message == null) { continue; } appendReferences(message.files); appendReferences(message.attachments); const contentCandidate = message.content; if (!Array.isArray(contentCandidate)) { continue; } const contentCount = captureProviderArrayLength(contentCandidate); const contentBudget = createMessageWorkBudget(budget, contentCandidate); let contentIndex = 0; for (; contentIndex < contentCount; contentIndex++) { if (!consumeProviderProjectionWork(contentBudget, 1)) { break; } const part = contentCandidate[contentIndex]; if (part == null) { continue; } appendReferences(part.files); const imageFile = part.image_file; if (imageFile != null) { appendReference(imageFile); } const file = part.file; if (file != null) { appendReference(file); } const directFileId = part.file_id; if (typeof directFileId === 'string') { appendFileId(directFileId); } } if (contentIndex < contentCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } } if (messageIndex < messageCount) { markProviderProjectionWorkOverflow(budget); } return { fileIds: [...fileIds], overflowed: budget.overflowed }; } /** Backward-compatible ID-only view for callers that do not enforce model-bound content. */ export function collectModelBoundHistoricalFileIds( messages: readonly (StoredMessageContentInput | null | undefined)[], ): string[] { return collectModelBoundHistoricalFileIdState(messages).fileIds; } /** * Builds the security-sensitive provider source/file association in typed * backend code. Legacy clients supply runtime state only; this helper owns * source normalization, deduplication, replay selection, and canonical-row * precedence for the final model-bound guard. */ export function projectModelBoundSourceFiles( input: ModelBoundSourceFileInput, ): ModelBoundSourceFileProjection { const fileIdsBySourceMessageId = new Map>(); let overflowed = input.initiallyOverflowed === true; let remainingAssociations = MAX_PROVIDER_PROJECTION_WORK; const appendFileId = (sourceMessageId: unknown, candidate: unknown): boolean => { if (remainingAssociations <= 0) { overflowed = true; return false; } remainingAssociations--; if (typeof sourceMessageId !== 'string') { return true; } const normalizedSourceId = sourceMessageId.trim(); if ( normalizedSourceId.length === 0 || normalizedSourceId.length > MAX_PROVIDER_SOURCE_MESSAGE_ID_LENGTH ) { return true; } let rawFileId: unknown; if (typeof candidate === 'string') { rawFileId = candidate; } else if (candidate != null && typeof candidate === 'object') { rawFileId = (candidate as ModelBoundFileReference)?.file_id; } if (typeof rawFileId !== 'string') { return true; } const fileId = rawFileId.trim(); if (fileId.length === 0) { return true; } const fileIds = fileIdsBySourceMessageId.get(normalizedSourceId) ?? new Set(); fileIds.add(fileId); fileIdsBySourceMessageId.set(normalizedSourceId, fileIds); return true; }; const appendFileIdArray = (sourceMessageId: unknown, candidate: unknown): void => { try { if (!Array.isArray(candidate)) { if (candidate != null) { overflowed = true; } return; } const candidateLength = captureProviderArrayLength(candidate); let index = 0; for (; index < candidateLength; index++) { if (remainingAssociations <= 0) { overflowed = true; break; } if (!appendFileId(sourceMessageId, candidate[index])) { break; } } if (index < candidateLength) { overflowed = true; } } catch { overflowed = true; } }; const appendSteerFileIds = (sourceMessageId: unknown, candidate: unknown): void => { try { if (Array.isArray(candidate)) { appendFileIdArray(sourceMessageId, candidate); return; } if (!(candidate instanceof Set)) { if (candidate != null) { overflowed = true; } return; } const values = Set.prototype.values.call(candidate) as IterableIterator; while (remainingAssociations > 0) { const next = values.next(); if (next.done) { return; } appendFileId(sourceMessageId, next.value); } if (!values.next().done) { overflowed = true; } } catch { overflowed = true; } }; const appendSourceMessageFiles = ( messageFiles: Readonly>, sourceMessageId: unknown, ): void => { if ( typeof sourceMessageId === 'string' && Object.prototype.hasOwnProperty.call(messageFiles, sourceMessageId) ) { appendFileIdArray(sourceMessageId, messageFiles[sourceMessageId]); } }; try { const messageFiles = input.messageFilesBySourceMessageId; if (messageFiles != null) { const sourceMessages = input.sourceMessages; if (!Array.isArray(sourceMessages)) { overflowed = true; } else { const sourceMessageLength = captureProviderArrayLength(sourceMessages); const sourceMessageCount = Math.min(sourceMessageLength, MAX_PROVIDER_PROJECTION_WORK); if (sourceMessageLength > sourceMessageCount) { overflowed = true; } for (let index = 0; index < sourceMessageCount; index++) { const message = sourceMessages[index]; if (message == null) { continue; } const messageId = message.messageId; const id = message.id; appendSourceMessageFiles(messageFiles, messageId); if (id !== messageId) { appendSourceMessageFiles(messageFiles, id); } } } } } catch { overflowed = true; } try { const steerFiles = input.steerFileIdsBySourceMessageId; if (steerFiles != null) { if (!(steerFiles instanceof Map)) { overflowed = true; } else { const entries = Map.prototype.entries.call(steerFiles) as IterableIterator< [string, readonly string[] | ReadonlySet] >; let entryCount = 0; while (entryCount < MAX_PROVIDER_PROJECTION_WORK) { const next = entries.next(); if (next.done) { break; } entryCount++; appendSteerFileIds(next.value[0], next.value[1]); } if (entryCount === MAX_PROVIDER_PROJECTION_WORK && !entries.next().done) { overflowed = true; } } } } catch { overflowed = true; } const resolvedFilesById = new Map(); let remainingResolvedFiles = MAX_PROVIDER_PROJECTION_WORK; const appendResolvedFile = (file: unknown): boolean => { if (remainingResolvedFiles <= 0) { overflowed = true; return false; } remainingResolvedFiles--; if (file == null || typeof file !== 'object') { return true; } const candidate = file as ModelBoundCanonicalFile; const rawFileId = candidate.file_id; if (typeof rawFileId !== 'string') { return true; } const fileId = rawFileId.trim(); if (fileId.length > 0) { resolvedFilesById.set(fileId, candidate); } return true; }; const appendResolvedFiles = (candidate: unknown): void => { try { if (candidate == null) { return; } if (Array.isArray(candidate)) { const fileLength = captureProviderArrayLength(candidate); let index = 0; for (; index < fileLength; index++) { if (remainingResolvedFiles <= 0) { overflowed = true; break; } if (!appendResolvedFile(candidate[index])) { break; } } if (index < fileLength) { overflowed = true; } return; } if (!(candidate instanceof Map)) { overflowed = true; return; } const values = Map.prototype.values.call(candidate) as IterableIterator< ModelBoundCanonicalFile | null | undefined >; while (remainingResolvedFiles > 0) { const next = values.next(); if (next.done) { return; } appendResolvedFile(next.value); } if (!values.next().done) { overflowed = true; } } catch { overflowed = true; } }; if (input.replayHistoricalFiles) { appendResolvedFiles(input.historicalFiles); } appendResolvedFiles(input.processedCurrentFiles); /** Canonical current rows come last so OCR/extraction coverage survives * provider encoding that intentionally reduces transport metadata. */ appendResolvedFiles(input.canonicalCurrentFiles); const projectedFileIds = new Map(); for (const [sourceMessageId, fileIds] of fileIdsBySourceMessageId) { projectedFileIds.set(sourceMessageId, [...fileIds]); } return { fileIdsBySourceMessageId: projectedFileIds, resolvedFiles: [...resolvedFilesById.values()], overflowed, }; } export interface ModelBoundChatModelCallback { readonly name: 'librechat-model-bound-content-filter'; readonly raiseError: true; readonly awaitHandlers: true; readonly handleChatModelStart: ( llm: object | undefined, messageBatches: readonly (readonly ModelBoundProviderMessage[])[], runId?: string, parentRunId?: string, extraParams?: Record, tags?: string[], metadata?: Record, ) => void | Promise; } export interface InitialModelBoundAdmissionCallback { readonly name: 'librechat-initial-model-bound-admission'; readonly raiseError: true; readonly awaitHandlers: true; readonly handleChatModelStart: ( llm: object | undefined, messageBatches: readonly (readonly ModelBoundProviderMessage[])[], runId: string, parentRunId?: string, extraParams?: Record, tags?: string[], metadata?: Record, ) => void; readonly handleChainStart: ( chain: object | undefined, inputs: unknown, runId: string, /** CallbackManager dispatches parentRunId here at runtime even though * BaseCallbackHandlerMethodsClass's published declaration labels this * position runType. Keep this signature aligned with manager dispatch. */ parentRunId?: string, tags?: string[], metadata?: Record, runType?: string, runName?: string, extra?: Record, ) => void; readonly handleLLMEnd: (output: unknown, runId: string) => void; readonly handleLLMError: (error: unknown, runId: string) => void; readonly handleChainEnd: (outputs: unknown, runId: string) => void; readonly handleChainError: (error: unknown, runId: string) => void; } export interface InitialModelBoundAdmission { readonly agentIds: readonly string[]; readonly isActive: () => boolean; readonly onAllowed: () => void; } export interface ModelBoundContentInput { readonly onTraversalFailure?: LocatorTraversalReporter; readonly filters?: FiltersConfig; readonly legacyPii?: MessageFilterPiiConfig; /** Exact generated tokens from server-owned canonical user rows, never request metadata. */ readonly privateTextTokens?: ReadonlySet; /** Fresh API input: every role is caller-submitted. */ readonly submittedMessages?: readonly ModelBoundMessage[]; /** Persisted chat history: user rows plus structured tool fragments are re-inspected. */ readonly storedMessages?: readonly StoredModelBoundMessage[]; readonly agents?: readonly (AgentContentInput | null | undefined)[]; readonly assistants?: readonly (AssistantContentInput | null | undefined)[]; readonly actions?: readonly (AssistantActionContentInput | null | undefined)[]; readonly skills?: readonly (SkillContentInput | null | undefined)[]; readonly memories?: readonly (MemoryContentInput | string | null | undefined)[]; readonly files?: readonly (FileContentInput | string | null | undefined)[]; /** * Owner-scoped canonical file rows that authorize durable file locators in * stored messages. The rows are inspected before their IDs are omitted from * the fail-close traversal copy. */ readonly resolvedFiles?: readonly (ModelBoundCanonicalFile | null | undefined)[]; /** Internal fail-closed provenance errors evaluated after files and findings. */ readonly deferredTraversalErrors?: readonly ContentTraversalLimitError[]; /** Internal aggregate nested-work budget shared by one provider callback invocation. */ readonly traversalBudget?: VisitNestedStringsBudget; } /** * Whether a policy can inspect content at a model/provider boundary. * Management-only sources and attribution behavior do not activate this gate. */ export function hasModelBoundContentProtection( filters: FiltersConfig | null | undefined, legacyPii?: MessageFilterPiiConfig | null, ): boolean { return ( hasActivePiiPatterns(legacyPii) || hasActivePiiPatterns(filters?.messages?.pii) || hasActivePiiPatterns(filters?.agentInstructions?.pii) || hasActivePiiPatterns(filters?.conversationStarters?.pii) || hasActivePiiPatterns(filters?.skills?.pii) || hasActivePiiPatterns(filters?.memories?.pii) || hasActiveFilePolicy(filters ?? undefined) || hasActivePiiPatterns(filters?.toolArguments?.pii) || hasActivePiiPatterns(filters?.modelParameters?.pii) || hasActivePiiPatterns(filters?.actionMetadata?.pii) ); } function normalizeRole(message: { readonly role?: string; readonly _getType?: () => string; }): string | undefined { const rawRole = message.role ?? message._getType?.(); switch (rawRole) { case 'human': return 'user'; case 'ai': return 'assistant'; default: return rawRole; } } function assertInspectableFileInput(filters: FiltersConfig | undefined, input: unknown): void { const field = getBlockedOpaqueFileField(filters, input); if (field != null) { throw new UninspectableFileError(field); } } type RuntimeAgentFileContainer = AgentContentInput & { readonly attachments?: readonly (FileContentInput | null | undefined)[]; readonly requestAttachments?: readonly (FileContentInput | null | undefined)[]; readonly agentContextAttachments?: readonly (FileContentInput | null | undefined)[]; readonly tool_resources?: Readonly< Record< string, | { readonly files?: readonly (FileContentInput | null | undefined)[]; } | null | undefined > >; }; function getHydratedAgentFiles( agent: AgentContentInput | null | undefined, ): ModelBoundCanonicalFile[] { if (agent == null) { return []; } const runtimeAgent = agent as RuntimeAgentFileContainer; const files: ModelBoundCanonicalFile[] = []; const append = (values: readonly (FileContentInput | null | undefined)[] | undefined) => { for (const file of values ?? []) { if (file != null) { files.push(file); } } }; append(runtimeAgent.attachments); append(runtimeAgent.requestAttachments); append(runtimeAgent.agentContextAttachments); for (const resource of Object.values(runtimeAgent.tool_resources ?? {})) { append(resource?.files); } return files; } function isFragmentWithinPath(fragment: TextContentFragment, path: JsonPointer): boolean { return fragment.path === path || fragment.path.startsWith(`${path}/`); } function isFragmentWithinSubmittedPaths( fragment: TextContentFragment, submittedPaths: ReadonlySet, ): boolean { let candidate = fragment.path as string; while (candidate.length > 0) { if (submittedPaths.has(candidate)) { return true; } const separator = candidate.lastIndexOf('/'); if (separator <= 0) { return false; } candidate = candidate.slice(0, separator); } return false; } function asUserSubmittedMessageFragment( fragment: Extract, ): Extract { return { ...fragment, id: `${fragment.id}.user-submitted-message`, source: 'message', field: 'content_part', treatment: 'inspect_only', }; } function getExactUserSubmittedMessageFragments( fragments: readonly TextContentFragment[], entries: readonly UserSubmittedMessageFieldPath[], ): Array> { const exact: Array> = []; const seen = new Set(); for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) { const entry = entries[entryIndex]; const path = entry.path as JsonPointer; for (const fragment of fragments) { if ( (fragment.source !== 'message' && fragment.source !== 'tool_argument') || !isFragmentWithinPath(fragment, path) ) { continue; } const key = `${entry.field}:${fragment.path}:${fragment.text}`; if (seen.has(key)) { continue; } seen.add(key); exact.push({ ...fragment, id: `${fragment.id}.user-submitted-${entry.field}.${entryIndex}`, source: 'message', field: entry.field, treatment: 'inspect_only', provenance: 'user', }); } } return exact; } /** * Rebuilds the model-equivalent aggregate from user-authored leaves only. * The stored adapter's aggregate spans the whole message, so using it for a * mixed assistant row would either include model prose or miss leaf-level * provenance marks rooted below `/content`. */ function createUserSubmittedAssembledContext( text: readonly string[], materializationBudget: VisitNestedStringsBudget, ): { readonly fragment?: Extract; readonly overflowed: boolean; } { if (text.length === 0) { return { overflowed: false }; } let materializedCharacters = 0; for (const value of text) { materializedCharacters += value.length; if (!Number.isSafeInteger(materializedCharacters)) { return { overflowed: true }; } } if ( text.length > 1 && !reserveContentMaterialization(materializationBudget, materializedCharacters) ) { return { overflowed: true }; } return { fragment: { id: 'stored-message.user-submitted-assembled', path: '/$assembled/user-submitted', text: text.length === 1 ? text[0] : text.join(''), source: 'assembled_context', field: 'assembled_context', format: 'plain', treatment: 'inspect_only', provenance: 'user', }, overflowed: false, }; } /** * Builds a sparse object containing only marked fields while retaining their * original keys and ancestry. File fail-close checks need that shape to * distinguish, for example, a submitted `file_id` from unrelated model data. */ function projectUserSubmittedPaths( message: StoredModelBoundMessage, paths: readonly JsonPointer[], ): Record | undefined { const projection = Object.create(null) as Record; let projected = false; for (const path of paths) { const segments = getSafeUserSubmittedPathSegments(path); if (segments == null) { continue; } let source: unknown = message; for (const segment of segments) { if ( source == null || typeof source !== 'object' || !Object.prototype.hasOwnProperty.call(source, segment) ) { source = undefined; break; } source = (source as Record)[segment]; } if (source === undefined) { continue; } let target: Record | unknown[] = projection; for (let index = 0; index < segments.length; index++) { const segment = segments[index]; if (index === segments.length - 1) { (target as Record)[segment] = source; projected = true; break; } const nextSegment = segments[index + 1]; const existing = (target as Record)[segment]; if (existing == null || typeof existing !== 'object') { (target as Record)[segment] = /^\d+$/.test(nextSegment) ? [] : Object.create(null); } target = (target as Record)[segment] as Record | unknown[]; } } return projected ? projection : undefined; } function extractExactUserSubmittedMessageFragments( message: StoredModelBoundMessage, entries: readonly UserSubmittedMessageFieldPath[], traversalBudget?: VisitNestedStringsBudget, ): { fragments: Array>; traversalError: ContentTraversalLimitError | null; } { const projectedMessage = projectUserSubmittedPaths( message, entries.map((entry) => entry.path as JsonPointer), ); if (projectedMessage == null) { return { fragments: [], traversalError: null }; } let projectedFragments: readonly TextContentFragment[]; let traversalError: ContentTraversalLimitError | null = null; try { projectedFragments = extractStoredMessageContent(projectedMessage, traversalBudget); } catch (error) { if (!isContentTraversalLimitError(error)) { throw error; } traversalError = error; projectedFragments = getContentTraversalFragments(error); } return { fragments: getExactUserSubmittedMessageFragments(projectedFragments, entries), traversalError, }; } function appendSourceMessageId(sourceIds: Set, candidate: string | undefined): void { if (typeof candidate !== 'string') { return; } const normalized = candidate.trim(); if (normalized.length > 0) { sourceIds.add(normalized); } } interface ModelBoundProviderProvenanceState { readonly orderedContributions?: OrderedProviderSourceContributions; readonly invalid: boolean; } interface LegacyProviderLineage { readonly sourceIds: ReadonlySet; readonly hasPluralLineage: boolean; readonly invalid: boolean; } interface ProviderSourceContribution { readonly attribution: ModelBoundProviderAttribution; readonly sourceMessageId: string; readonly selectedContentPartIndices?: ReadonlySet; } interface OrderedProviderSourceContributions { readonly contributions: readonly ProviderSourceContribution[]; readonly hasUserAttribution: boolean; readonly hasToolAttribution: boolean; } function normalizeProviderSourceMessageId(candidate: unknown): string | undefined { if (typeof candidate !== 'string') { return undefined; } const sourceMessageId = candidate.trim(); if ( sourceMessageId.length === 0 || sourceMessageId.length > MAX_PROVIDER_SOURCE_MESSAGE_ID_LENGTH ) { return undefined; } return sourceMessageId; } function getProviderMessageProvenanceState( message: ModelBoundProviderMessage, parentBudget: ProviderProjectionWorkBudget, ): ModelBoundProviderProvenanceState { const candidate: unknown = message.additional_kwargs?.provenance; if (candidate == null) { return { invalid: false }; } if (typeof candidate !== 'object' || Array.isArray(candidate)) { return { invalid: true }; } const value = candidate as { readonly version?: unknown; readonly parts?: unknown }; const version = value.version; const candidateParts = value.parts; if (version !== 1 || !Array.isArray(candidateParts)) { return { invalid: true }; } const budget = createMessageWorkBudget( parentBudget, candidateParts, MAX_PROVIDER_PROVENANCE_PARSE_WORK, ); let candidatePartCount: number; try { candidatePartCount = captureProviderArrayLength(candidateParts); } catch { markProviderProjectionWorkOverflow(budget); return { invalid: true }; } if (candidatePartCount === 0 || candidatePartCount > MAX_PROVIDER_PROVENANCE_PARTS) { return { invalid: true }; } const contributions: Array<{ attribution: ModelBoundProviderAttribution; sourceMessageId: string; selectedContentPartIndices?: Set; }> = []; let hasUserAttribution = false; let hasToolAttribution = false; let totalIndexRefs = 0; for (let partIndex = 0; partIndex < candidatePartCount; partIndex++) { if (!consumeProviderProjectionWork(budget, 1)) { return { invalid: true }; } const candidatePart = candidateParts[partIndex]; if ( candidatePart == null || typeof candidatePart !== 'object' || Array.isArray(candidatePart) ) { return { invalid: true }; } const part = candidatePart as { readonly attribution?: unknown; readonly sourceMessageId?: unknown; readonly sourceContentPartIndices?: unknown; }; const attribution = part.attribution; const candidateSourceMessageId = part.sourceMessageId; const candidateSourceContentPartIndices = part.sourceContentPartIndices; if ( typeof attribution !== 'string' || !PROVIDER_PROVENANCE_ATTRIBUTIONS.has(attribution as ModelBoundProviderAttribution) ) { return { invalid: true }; } let sourceMessageId: string | undefined; if (candidateSourceMessageId !== undefined) { sourceMessageId = normalizeProviderSourceMessageId(candidateSourceMessageId); if (sourceMessageId == null) { return { invalid: true }; } } let sourceContentPartIndices: Set | undefined; if (candidateSourceContentPartIndices !== undefined) { if (!Array.isArray(candidateSourceContentPartIndices)) { return { invalid: true }; } let candidateIndexCount: number; try { candidateIndexCount = captureProviderArrayLength(candidateSourceContentPartIndices); } catch { markProviderProjectionWorkOverflow(budget); return { invalid: true }; } if (candidateIndexCount === 0 || candidateIndexCount > MAX_PROVIDER_SOURCE_PART_INDICES) { return { invalid: true }; } totalIndexRefs += candidateIndexCount; if (totalIndexRefs > MAX_PROVIDER_PROVENANCE_INDEX_REFS) { return { invalid: true }; } if ( !consumeProviderProjectionWork( isProxy(candidateSourceContentPartIndices) ? parentBudget : budget, candidateIndexCount, ) ) { return { invalid: true }; } sourceContentPartIndices = new Set(); for (let indexPosition = 0; indexPosition < candidateIndexCount; indexPosition++) { const index = candidateSourceContentPartIndices[indexPosition]; if ( !Number.isSafeInteger(index) || index < 0 || index > MAX_PROVIDER_SOURCE_CONTENT_PART_INDEX ) { return { invalid: true }; } sourceContentPartIndices.add(index); } } const normalizedAttribution = attribution as ModelBoundProviderAttribution; hasUserAttribution ||= normalizedAttribution === 'user'; hasToolAttribution ||= normalizedAttribution === 'tool'; if (sourceMessageId == null) { continue; } const existing = contributions[contributions.length - 1]; if ( existing == null || existing.attribution !== normalizedAttribution || existing.sourceMessageId !== sourceMessageId ) { contributions.push({ attribution: normalizedAttribution, sourceMessageId, ...(sourceContentPartIndices != null && { selectedContentPartIndices: sourceContentPartIndices, }), }); continue; } if (existing.selectedContentPartIndices == null) { continue; } if (sourceContentPartIndices == null) { delete existing.selectedContentPartIndices; continue; } for (const index of sourceContentPartIndices) { existing.selectedContentPartIndices.add(index); } } return { orderedContributions: { contributions, hasUserAttribution, hasToolAttribution }, invalid: false, }; } function getLegacyProviderLineage( message: ModelBoundProviderMessage, parentBudget: ProviderProjectionWorkBudget, ): LegacyProviderLineage { const sourceIds = new Set(); let invalid = false; let hasPluralLineage = false; const pluralCandidate: unknown = message.additional_kwargs?.sourceMessageIds; const budget = createMessageWorkBudget( parentBudget, pluralCandidate, MAX_PROVIDER_PROVENANCE_PARSE_WORK, ); if (pluralCandidate != null) { if (!Array.isArray(pluralCandidate)) { invalid = true; } else { let sourceMessageIdCount: number; try { sourceMessageIdCount = captureProviderArrayLength(pluralCandidate); } catch { markProviderProjectionWorkOverflow(budget); invalid = true; sourceMessageIdCount = 0; } if (sourceMessageIdCount > MAX_PROVIDER_SOURCE_MESSAGE_IDS) { invalid = true; } else { hasPluralLineage = sourceMessageIdCount > 0; for (let index = 0; index < sourceMessageIdCount; index++) { if (!consumeProviderProjectionWork(budget, 1)) { invalid = true; break; } const candidate = pluralCandidate[index]; const sourceMessageId = normalizeProviderSourceMessageId(candidate); if (sourceMessageId == null) { invalid = true; continue; } sourceIds.add(sourceMessageId); } } } } const appendCandidate = (candidate: unknown): void => { if (candidate == null) { return; } if (!consumeProviderProjectionWork(budget, 1)) { invalid = true; return; } const sourceMessageId = normalizeProviderSourceMessageId(candidate); if (sourceMessageId == null) { invalid = true; return; } sourceIds.add(sourceMessageId); }; appendCandidate(message.additional_kwargs?.sourceMessageId); appendCandidate(message.messageId); appendCandidate(message.id); return { sourceIds, hasPluralLineage, invalid }; } function isLegacyArtifactProjectionMarker(content: unknown): boolean { if (content === LEGACY_ARTIFACT_PROJECTION_MARKER) { return true; } if (!Array.isArray(content) || content.length !== 1) { return false; } const part = content[0]; if (part == null || typeof part !== 'object') { return false; } const value = part as { readonly text?: unknown; readonly content?: unknown }; return ( value.text === LEGACY_ARTIFACT_PROJECTION_MARKER || value.content === LEGACY_ARTIFACT_PROJECTION_MARKER ); } /** @librechat/agents 3.6.9 projects artifact-bearing ToolMessages into an * untyped terminal HumanMessage. Recognize only that generated adjacency and * exact marker; ordinary untyped HumanMessages must retain user attribution. */ function isLegacyArtifactProjectionHuman( messages: readonly ModelBoundProviderMessage[], roles: readonly (string | undefined)[], contents: readonly unknown[], index: number, provenanceState: ModelBoundProviderProvenanceState, legacyLineage: LegacyProviderLineage, ): boolean { const message = messages[index]; if ( message == null || index !== messages.length - 1 || provenanceState.orderedContributions != null || provenanceState.invalid || roles[index] !== 'user' || legacyLineage.invalid || message.additional_kwargs?.sourceMessageId != null || message.additional_kwargs?.sourceMessageIds != null || message.messageId != null ) { return false; } const metadata = message.additional_kwargs; if (metadata?.isMeta === true || metadata?.injected === true || metadata?.source != null) { return false; } for (let previousIndex = index - 1; previousIndex >= 0; previousIndex--) { if (roles[previousIndex] !== 'tool') { break; } if (isLegacyArtifactProjectionMarker(contents[previousIndex])) { return true; } } return false; } function getLegacyCoalescedCanonicalScopes( filters: FiltersConfig | undefined, ): ContentTraversalScope[] { const scopes: ContentTraversalScope[] = []; const messagePii = filters?.messages?.pii; const selectedHitlFields = HITL_MESSAGE_FILTER_FIELDS.filter( (field) => messagePii?.fields == null || messagePii.fields.includes(field), ); if (selectedHitlFields.length > 0 && hasActivePiiFields(messagePii, selectedHitlFields)) { scopes.push({ source: 'message', fields: selectedHitlFields, }); } const filePii = filters?.files?.pii; const selectedFileFields = FILE_FILTER_FIELDS.filter( (field) => filePii?.fields == null || filePii.fields.includes(field), ); if ( selectedFileFields.length > 0 && (hasActivePiiFields(filePii, selectedFileFields) || getBlockedUninspectableFileField(filters, selectedFileFields) != null) ) { scopes.push({ source: 'file', fields: selectedFileFields }); } return scopes; } function getLegacyCoalescedLineageError( input: ModelBoundProviderContentInput, providerRole: string | undefined, matchedStoredMessages: ReadonlySet, provenanceState: ModelBoundProviderProvenanceState, legacyLineage: LegacyProviderLineage, ): ContentTraversalLimitError | null { if (provenanceState.orderedContributions != null) { return null; } const hasInvalidLineage = provenanceState.invalid || legacyLineage.invalid; const hasAmbiguousLegacyCoalescing = providerRole === 'user' && !legacyLineage.hasPluralLineage && matchedStoredMessages.size >= 2; if (!hasInvalidLineage && !hasAmbiguousLegacyCoalescing) { return null; } const scopes = getLegacyCoalescedCanonicalScopes(input.filters); if (scopes.length > 0) { return new ContentTraversalLimitError([], scopes); } return null; } function getStoredMessageIds(message: StoredModelBoundMessage): Set { const messageIds = new Set(); appendSourceMessageId(messageIds, message.messageId); appendSourceMessageId(messageIds, message.id); return messageIds; } function appendReferencedFileIds( fileIds: Set, references: readonly ({ readonly file_id?: string } | null | undefined)[] | null | undefined, budget: ProviderProjectionWorkBudget, ): void { try { if (!Array.isArray(references)) { return; } const referenceCount = captureProviderArrayLength(references); let index = 0; for (; index < referenceCount; index++) { if (!appendReferencedFileId(fileIds, references[index], budget)) { break; } } if (index < referenceCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } } function appendReferencedFileId( fileIds: Set, reference: { readonly file_id?: string } | null | undefined, budget: ProviderProjectionWorkBudget, ): boolean { return appendFileIdCandidate(fileIds, reference?.file_id, budget); } function appendFileIdCandidate( fileIds: Set, candidate: unknown, budget: ProviderProjectionWorkBudget, ): boolean { if (!consumeProviderProjectionWork(budget, 1)) { return false; } if (typeof candidate !== 'string') { return true; } const fileId = candidate.trim(); if (fileId.length > 0) { fileIds.add(fileId); } return true; } function appendPartFileIds( fileIds: Set, part: NonNullable[number]>, budget: ProviderProjectionWorkBudget, ) { try { appendReferencedFileIds(fileIds, part.files, budget); const imageFile = part.image_file; if (imageFile != null) { appendReferencedFileId(fileIds, imageFile, budget); } const file = part.file; if (file != null) { appendReferencedFileId(fileIds, file, budget); } const directFileId = part.file_id; if (typeof directFileId === 'string') { appendFileIdCandidate(fileIds, directFileId, budget); } } catch { markProviderProjectionWorkOverflow(budget); } } function appendStoredMessageFileIds( fileIds: Set, message: StoredModelBoundMessage, filters: FiltersConfig | undefined, budget: ProviderProjectionWorkBudget, ): void { const submittedPathState = getUserSubmittedPathState(message); const role = normalizeRole(message); const isEntireMessageUserSubmitted = message.isCreatedByUser === true || message.isUserSubmitted === true || (role === 'user' && message.isCreatedByUser !== false && message.isUserSubmitted !== false) || role === 'tool' || submittedPathState.overflowed || (filters?.messages?.unattributedAssistantContent === 'inspect' && typeof message.isUserSubmitted !== 'boolean' && submittedPathState.paths.length === 0 && (message.isCreatedByUser === false || role === 'assistant')); if (isEntireMessageUserSubmitted) { appendReferencedFileIds(fileIds, message.files, budget); } const submittedFilePartIndices = new Set(); for (const path of submittedPathState.paths) { const segments = getSafeUserSubmittedPathSegments(path); if ( segments?.[0] !== 'content' || !/^\d+$/.test(segments[1] ?? '') || (segments.length > 2 && !['file', 'file_id', 'files', 'image_file'].includes(segments[2])) ) { continue; } submittedFilePartIndices.add(Number(segments[1])); } try { const contentCandidate = message.content; if (!Array.isArray(contentCandidate)) { return; } const contentCount = captureProviderArrayLength(contentCandidate); const contentBudget = createMessageWorkBudget(budget, contentCandidate); let index = 0; for (; index < contentCount; index++) { if (!consumeProviderProjectionWork(contentBudget, 1)) { break; } const part = contentCandidate[index]; if (part == null) { continue; } if (isEntireMessageUserSubmitted || submittedFilePartIndices.has(index)) { appendPartFileIds(fileIds, part, budget); } } if (index < contentCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } } type ProviderExactAttribution = 'user' | 'tool' | 'non_user'; const MODEL_BOUND_CONTENT_PART_KEYS = [ 'type', 'text', 'think', 'original', 'updated', 'steer', 'error', 'image_url', 'video_url', 'input_audio', 'image_file', 'file', 'files', 'file_id', 'filename', 'content', 'tool_call', 'data', 'url', 'source_type', 'source', 'document', 'payload', ] as const; const MODEL_BOUND_FILE_PART_KEYS = new Set(['file', 'files', 'image_file', 'file_id']); interface ModelBoundPartSnapshotContext { readonly budget: ProviderProjectionWorkBudget; readonly seen: WeakMap; } function snapshotModelBoundPartArray( candidate: readonly unknown[], context: ModelBoundPartSnapshotContext, snapshotItem: (value: unknown) => unknown, ): readonly unknown[] { const existing = context.seen.get(candidate); if (existing != null) { return existing as readonly unknown[]; } const snapshot: unknown[] = []; context.seen.set(candidate, snapshot); try { if (isProxy(candidate)) { markProviderProjectionWorkOverflow(context.budget); return snapshot; } const length = captureProviderArrayLength(candidate); let index = 0; for (; index < length; index++) { if (!consumeProviderProjectionWork(context.budget, 1)) { break; } snapshot.push(snapshotItem(candidate[index])); } if (index < length) { markProviderProjectionWorkOverflow(context.budget); } } catch { markProviderProjectionWorkOverflow(context.budget); } return snapshot; } function snapshotModelBoundPartObject( candidate: object, knownKeys: readonly string[], context: ModelBoundPartSnapshotContext, snapshotValue: (key: string, value: unknown) => unknown, omittedKeys: ReadonlySet = new Set(), ): Readonly> { const existing = context.seen.get(candidate); if (existing != null) { return existing as Readonly>; } const snapshot = Object.create(null) as Record; context.seen.set(candidate, snapshot); const seenKeys = new Set(); let candidateIsProxy = false; try { candidateIsProxy = isProxy(candidate); } catch { markProviderProjectionWorkOverflow(context.budget); return snapshot; } if (candidateIsProxy) { markProviderProjectionWorkOverflow(context.budget); } else { const entryLimit = knownKeys.length + context.budget.remaining; const boundedEntries = getBoundedOwnEnumerableEntries(candidate, entryLimit); for (const [key, value] of boundedEntries.entries) { seenKeys.add(key); if (omittedKeys.has(key)) { continue; } if (!knownKeys.includes(key)) { if (!consumeProviderProjectionWork(context.budget, 1)) { break; } } snapshot[key] = snapshotValue(key, value); } if (!boundedEntries.complete) { markProviderProjectionWorkOverflow(context.budget); } } for (const key of knownKeys) { if (seenKeys.has(key) || omittedKeys.has(key)) { continue; } try { if (Object.prototype.hasOwnProperty.call(candidate, key)) { snapshot[key] = snapshotValue(key, (candidate as Record)[key]); } } catch { markProviderProjectionWorkOverflow(context.budget); } } return snapshot; } function snapshotGenericModelBoundPartValue( value: unknown, context: ModelBoundPartSnapshotContext, depth = 0, ): unknown { if (value == null || typeof value !== 'object') { return value; } if (depth > CONTENT_TRAVERSAL_MAX_DEPTH) { markProviderProjectionWorkOverflow(context.budget); return undefined; } let valueIsArray = false; try { valueIsArray = Array.isArray(value); } catch { markProviderProjectionWorkOverflow(context.budget); return undefined; } if (valueIsArray) { return snapshotModelBoundPartArray(value as readonly unknown[], context, (item) => snapshotGenericModelBoundPartValue(item, context, depth + 1), ); } return snapshotModelBoundPartObject(value, [], context, (_key, child) => snapshotGenericModelBoundPartValue(child, context, depth + 1), ); } function snapshotPartWrapper( value: unknown, keys: readonly string[], context: ModelBoundPartSnapshotContext, snapshotValue: (key: string, child: unknown) => unknown = (_key, child) => snapshotGenericModelBoundPartValue(child, context), ): unknown { if (value == null || typeof value !== 'object' || Array.isArray(value)) { return value; } return snapshotModelBoundPartObject(value, keys, context, snapshotValue); } function snapshotModelBoundPartProperty( key: string, value: unknown, context: ModelBoundPartSnapshotContext, ): unknown { switch (key) { case 'content': // Stabilize nested children for both extraction and later opaque-file checks. // The submissions adapter still owns the shared nested traversal accounting. return Array.isArray(value) ? snapshotModelBoundPartArray(value, context, (child) => snapshotGenericModelBoundPartValue(child, context), ) : snapshotGenericModelBoundPartValue(value, context); case 'text': case 'think': return snapshotPartWrapper(value, ['value'], context); case 'image_url': return snapshotPartWrapper(value, ['url', 'detail'], context); case 'video_url': return snapshotPartWrapper(value, ['url'], context); case 'input_audio': return snapshotPartWrapper(value, ['data', 'format'], context); case 'image_file': return snapshotPartWrapper(value, ['file_id', 'filename'], context); case 'file': return snapshotPartWrapper( value, [ 'file_id', 'file_data', 'name', 'filename', 'originalname', 'filepath', 'uri', 'url', 'preview', ], context, ); case 'files': return Array.isArray(value) ? snapshotModelBoundPartArray(value, context, (file) => snapshotPartWrapper( file, [ 'file_id', 'file_data', 'name', 'filename', 'originalname', 'filepath', 'uri', 'url', 'preview', ], context, ), ) : value; case 'source': return snapshotPartWrapper(value, ['type', 'data', 'url'], context); case 'tool_call': return snapshotPartWrapper( value, ['name', 'args', 'arguments', 'output', 'function', 'code_interpreter'], context, (toolKey, child) => { if (toolKey === 'function') { return snapshotPartWrapper(child, ['name', 'arguments', 'output'], context); } if (toolKey === 'code_interpreter') { return snapshotPartWrapper(child, ['input', 'outputs'], context); } return snapshotGenericModelBoundPartValue(child, context); }, ); default: return snapshotGenericModelBoundPartValue(value, context); } } function snapshotModelBoundContentPart( part: unknown, budget: ProviderProjectionWorkBudget, options: { readonly omitFileReferences?: boolean } = {}, ): unknown { if (part == null || typeof part !== 'object') { return part; } const context: ModelBoundPartSnapshotContext = { budget, seen: new WeakMap(), }; const snapshot = snapshotModelBoundPartObject( part, MODEL_BOUND_CONTENT_PART_KEYS, context, (key, value) => snapshotModelBoundPartProperty(key, value, context), options.omitFileReferences === true ? MODEL_BOUND_FILE_PART_KEYS : undefined, ) as Record; return snapshot; } function cloneSnapshottedContentPartWithTextType( part: object, budget: ProviderProjectionWorkBudget, ): Readonly> { const snapshot = Object.create(null) as Record; const boundedEntries = getBoundedOwnEnumerableEntries( part, MODEL_BOUND_CONTENT_PART_KEYS.length + MAX_PROVIDER_PROJECTION_WORK, ); for (const [key, value] of boundedEntries.entries) { snapshot[key] = value; } if (!boundedEntries.complete) { markProviderProjectionWorkOverflow(budget); } snapshot.type = 'text'; return snapshot; } function cloneSnapshottedContentPartWithoutFileReferences( part: unknown, budget: ProviderProjectionWorkBudget, ): unknown { if (part == null || typeof part !== 'object') { return part; } try { if (isProxy(part)) { markProviderProjectionWorkOverflow(budget); return undefined; } } catch { markProviderProjectionWorkOverflow(budget); return undefined; } const snapshot = Object.create(null) as Record; const boundedEntries = getBoundedOwnEnumerableEntries( part, MODEL_BOUND_CONTENT_PART_KEYS.length + MAX_PROVIDER_PROJECTION_WORK, ); for (const [key, value] of boundedEntries.entries) { if (!MODEL_BOUND_FILE_PART_KEYS.has(key)) { snapshot[key] = value; } } if (!boundedEntries.complete) { markProviderProjectionWorkOverflow(budget); } return snapshot; } function snapshotProviderMessageEnvelope( message: ModelBoundProviderMessage, budget: ProviderProjectionWorkBudget, ): SnapshottedModelBoundProviderMessage { const read = (getter: () => Value): Value | undefined => { try { return getter(); } catch { markProviderProjectionWorkOverflow(budget); return undefined; } }; const additionalKwargs = read(() => message.additional_kwargs); const additionalKwargsSnapshot = additionalKwargs == null ? undefined : { injected: read(() => additionalKwargs.injected), isMeta: read(() => additionalKwargs.isMeta), source: read(() => additionalKwargs.source), sourceMessageId: read(() => additionalKwargs.sourceMessageId), sourceMessageIds: read(() => additionalKwargs.sourceMessageIds), provenance: read(() => additionalKwargs.provenance), }; const extendedMessage = message as ModelBoundProviderMessage & StoredModelBoundMessage; return { id: read(() => message.id), messageId: read(() => message.messageId), role: read(() => normalizeRole(message)), name: read(() => message.name), sender: read(() => extendedMessage.sender), text: read(() => message.text), summary: read(() => extendedMessage.summary), quotes: read(() => extendedMessage.quotes), content: read(() => message.content), tool_calls: read(() => message.tool_calls), files: read(() => extendedMessage.files), attachments: read(() => extendedMessage.attachments), original: read(() => extendedMessage.original), updated: read(() => extendedMessage.updated), feedback: read(() => extendedMessage.feedback), isCreatedByUser: read(() => extendedMessage.isCreatedByUser), isUserSubmitted: read(() => extendedMessage.isUserSubmitted), userSubmittedPaths: read(() => extendedMessage.userSubmittedPaths), userSubmittedMessageFieldPaths: read(() => extendedMessage.userSubmittedMessageFieldPaths), additional_kwargs: additionalKwargsSnapshot, }; } function snapshotProviderMessageContent( message: ModelBoundProviderMessage, parentBudget: ProviderProjectionWorkBudget, parentPartSnapshotBudget: ProviderProjectionWorkBudget, ): unknown { const budget = createMessageWorkBudget(parentBudget, message.content); const partSnapshotBudget = createMessageWorkBudget(parentPartSnapshotBudget, message.content); try { const messageContent = message.content; const messageText = messageContent == null ? message.text : undefined; const candidate = messageContent ?? messageText; if (!Array.isArray(candidate)) { return candidate; } const candidateLength = captureProviderArrayLength(candidate); const content: unknown[] = []; let index = 0; for (; index < candidateLength; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } content.push(snapshotModelBoundContentPart(candidate[index], partSnapshotBudget)); } if (index < candidateLength) { markProviderProjectionWorkOverflow(budget); } return content; } catch { markProviderProjectionWorkOverflow(budget); return undefined; } } function projectProviderMessage( message: SnapshottedModelBoundProviderMessage, attribution: ProviderExactAttribution | undefined, capturedProviderContent: unknown, providerRole: string | undefined, partSnapshotBudget: ProviderProjectionWorkBudget, ): StoredModelBoundMessage { const role = attribution === 'tool' ? 'tool' : providerRole; const providerSource = message.additional_kwargs?.source; const isSyntheticContext = message.additional_kwargs?.isMeta === true || (typeof providerSource === 'string' && LEGACY_SYNTHETIC_PROVIDER_SOURCES.has(providerSource)) || (message.additional_kwargs?.injected === true && providerSource !== 'steer'); const isUser = attribution === 'user' || (attribution == null && role === 'user' && !isSyntheticContext); const rawProviderContent = capturedProviderContent; let providerContent = rawProviderContent; if ((attribution === 'non_user' || attribution === 'tool') && Array.isArray(rawProviderContent)) { let projectedContent: unknown[] | undefined; const contentLength = rawProviderContent.length; for (let index = 0; index < contentLength; index++) { const part = rawProviderContent[index]; if (part == null || typeof part !== 'object' || part.type !== 'steer') { if (projectedContent != null) { projectedContent.push(part); } continue; } if (projectedContent == null) { projectedContent = rawProviderContent.slice(0, index); } projectedContent.push(cloneSnapshottedContentPartWithTextType(part, partSnapshotBudget)); } providerContent = projectedContent ?? rawProviderContent; } const projectedContentFields: { content?: StoredModelBoundMessage['content']; text?: string; } = {}; if (typeof providerContent === 'string') { projectedContentFields.text = providerContent; } else if (Array.isArray(providerContent)) { projectedContentFields.content = providerContent as StoredModelBoundMessage['content']; } return { id: message.id, messageId: message.messageId, role, name: message.name, sender: message.sender, summary: message.summary, quotes: message.quotes, tool_calls: message.tool_calls, files: message.files, attachments: message.attachments, original: message.original, updated: message.updated, feedback: message.feedback, userSubmittedPaths: message.userSubmittedPaths, userSubmittedMessageFieldPaths: message.userSubmittedMessageFieldPaths, isCreatedByUser: isUser, isUserSubmitted: isUser, ...projectedContentFields, }; } function projectStoredMessageForProvider( message: StoredModelBoundMessage, parentBudget: ProviderProjectionWorkBudget, partSnapshotBudget: ProviderProjectionWorkBudget, selectedContentPartIndices?: ReadonlySet, attribution?: Extract, capturedContentParts?: Map, capturedContentLength?: number, submittedPathsSnapshot?: readonly string[], submittedFieldPathsSnapshot?: readonly UserSubmittedMessageFieldPath[], ): StoredModelBoundMessage { const budget = createMessageWorkBudget(parentBudget, message.content); const messageContentCandidate = message.content; const storedText = message.text; const rawFieldPathCandidate = message.userSubmittedMessageFieldPaths; const rawPathCandidate = message.userSubmittedPaths; const pathCandidate = submittedPathsSnapshot ?? rawPathCandidate; const fieldPathCandidate = submittedFieldPathsSnapshot ?? rawFieldPathCandidate; const providerMessage: StoredModelBoundMessage = { id: message.id, messageId: message.messageId, role: message.role, isCreatedByUser: message.isCreatedByUser, isUserSubmitted: message.isUserSubmitted, ...(messageContentCandidate == null && storedText != null && (selectedContentPartIndices == null || selectedContentPartIndices.has(0)) ? { text: storedText } : {}), ...(attribution === 'user' && { isCreatedByUser: true, isUserSubmitted: true, }), ...(attribution === 'tool' && { role: 'tool', isCreatedByUser: false, isUserSubmitted: false, }), }; let hasArrayContent = false; let messageContentLength = 0; let messageContent: NonNullable | undefined; try { hasArrayContent = Array.isArray(messageContentCandidate); if (hasArrayContent) { messageContent = messageContentCandidate as NonNullable; messageContentLength = capturedContentLength ?? captureProviderArrayLength(messageContent); if (!Number.isSafeInteger(messageContentLength) || messageContentLength < 0) { throw new TypeError('invalid captured stored content length'); } } else { consumeProviderProjectionWork(budget, 1); } } catch { markProviderProjectionWorkOverflow(budget); return providerMessage; } const projectPart = ( part: NonNullable[number], ): NonNullable[number] => { return cloneSnapshottedContentPartWithoutFileReferences( part, partSnapshotBudget, ) as NonNullable[number]; }; const compactIndexBySourceIndex = new Map(); const content: Array[number]> = []; const readContentPart = ( index: number, ): NonNullable[number] => { if (capturedContentParts?.has(index) === true) { return capturedContentParts.get(index) as NonNullable< StoredMessageContentInput['content'] >[number]; } const rawPart = messageContent?.[index] as NonNullable< StoredMessageContentInput['content'] >[number]; const part = snapshotModelBoundContentPart(rawPart, partSnapshotBudget); capturedContentParts?.set(index, part); return part as NonNullable[number]; }; if (hasArrayContent && selectedContentPartIndices == null) { let index = 0; try { for (; index < messageContentLength; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } compactIndexBySourceIndex.set(index, content.length); content.push(projectPart(readContentPart(index))); } } catch { markProviderProjectionWorkOverflow(budget); } if (index < messageContentLength) { markProviderProjectionWorkOverflow(budget); } } else if (hasArrayContent && selectedContentPartIndices != null) { const selectedIndices = [...selectedContentPartIndices] .filter((index) => Number.isSafeInteger(index) && index >= 0 && index < messageContentLength) .sort((left, right) => left - right); for (const sourceIndex of selectedIndices) { if (!consumeProviderProjectionWork(budget, 1)) { break; } try { const part = readContentPart(sourceIndex); if (part == null) { continue; } compactIndexBySourceIndex.set(sourceIndex, content.length); content.push(projectPart(part)); } catch { markProviderProjectionWorkOverflow(budget); break; } } } const remapSelectedPath = (value: unknown): JsonPointer | undefined => { if (typeof value !== 'string' || !value.startsWith('/')) { return undefined; } const segments = getSafeUserSubmittedPathSegments(value as JsonPointer); const encodedIndex = segments?.[1]; if ( segments?.[0] !== 'content' || encodedIndex == null || !/^\d+$/.test(encodedIndex) || String(Number(encodedIndex)) !== encodedIndex ) { return undefined; } const compactIndex = compactIndexBySourceIndex.get(Number(encodedIndex)); if (compactIndex == null) { return undefined; } const sourcePrefix = `/content/${encodedIndex}`; return `/content/${compactIndex}${value.slice(sourcePrefix.length)}` as JsonPointer; }; const userSubmittedPaths: JsonPointer[] = []; const userSubmittedMessageFieldPaths: UserSubmittedMessageFieldPath[] = []; try { if (pathCandidate != null && !Array.isArray(pathCandidate)) { markProviderProjectionWorkOverflow(budget); } else if (Array.isArray(pathCandidate)) { const pathLength = captureProviderArrayLength(pathCandidate); const pathCount = Math.min(pathLength, MAX_PROVIDER_PROVENANCE_PARTS); let index = 0; for (; index < pathCount; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } const candidate = pathCandidate[index]; if (selectedContentPartIndices == null) { if (typeof candidate === 'string') { userSubmittedPaths.push(candidate as JsonPointer); } } else { const path = remapSelectedPath(candidate); if (path != null) { userSubmittedPaths.push(path); } } } if (index < pathLength || pathLength > pathCount) { markProviderProjectionWorkOverflow(budget); } } if (fieldPathCandidate != null && !Array.isArray(fieldPathCandidate)) { markProviderProjectionWorkOverflow(budget); } else if (Array.isArray(fieldPathCandidate)) { const fieldPathLength = captureProviderArrayLength(fieldPathCandidate); const fieldPathCount = Math.min(fieldPathLength, MAX_PROVIDER_PROVENANCE_PARTS); let index = 0; for (; index < fieldPathCount; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } const entry = fieldPathCandidate[index]; if (selectedContentPartIndices == null) { if (entry != null && typeof entry === 'object') { userSubmittedMessageFieldPaths.push(entry); } } else { const path = remapSelectedPath(entry?.path); if (path != null) { userSubmittedMessageFieldPaths.push({ field: entry.field, path }); } } } if (index < fieldPathLength || fieldPathLength > fieldPathCount) { markProviderProjectionWorkOverflow(budget); } } } catch { markProviderProjectionWorkOverflow(budget); } return { ...providerMessage, userSubmittedPaths, userSubmittedMessageFieldPaths, ...(hasArrayContent && { content }), }; } interface StoredProviderContributionState { readonly isCanonicalUserContribution: boolean; } interface CachedStoredProviderState { readonly provenanceBudget: ProviderProjectionWorkBudget; readonly messageSnapshot: StoredModelBoundMessage; readonly contentLength?: number; readonly contentParts: Map; readonly partSnapshotBudget: ProviderProjectionWorkBudget; readonly explicitSubmittedPathState: ReturnType; readonly submittedMessageFieldState: ReturnType; explicitSubmittedPaths?: ReadonlySet; wholeSubmittedPathState?: ReturnType; submittedContentPartIndices?: ReadonlySet; submittedFieldContentPartIndices?: ReadonlySet; wholeRawFileIds?: ReadonlySet; } function readCachedStoredContentPart( cachedState: CachedStoredProviderState, index: number, budget: ProviderProjectionWorkBudget, ): unknown { if ( cachedState.contentLength == null || !Number.isSafeInteger(index) || index < 0 || index >= cachedState.contentLength ) { return undefined; } if (cachedState.contentParts.has(index)) { return cachedState.contentParts.get(index); } try { const content = cachedState.messageSnapshot.content; if (!Array.isArray(content)) { markProviderProjectionWorkOverflow(budget); return undefined; } const part = snapshotModelBoundContentPart(content[index], cachedState.partSnapshotBudget); cachedState.contentParts.set(index, part); return part; } catch { markProviderProjectionWorkOverflow(budget); return undefined; } } function getProviderContentSelectionKey( selectedContentPartIndices: ReadonlySet | undefined, ): string { return selectedContentPartIndices == null ? '*' : [...selectedContentPartIndices].sort((left, right) => left - right).join(','); } function markUniqueStoredSelection( selections: WeakMap>, message: StoredModelBoundMessage, key: string, ): boolean { const messageSelections = selections.get(message); if (messageSelections?.has(key) === true) { return false; } if (messageSelections == null) { selections.set(message, new Set([key])); } else { messageSelections.add(key); } return true; } function getStoredSubmittedPathState( selectedContentPartIndices: ReadonlySet | undefined, cachedState: CachedStoredProviderState, budget: ProviderProjectionWorkBudget, ): ReturnType { if (selectedContentPartIndices != null) { return cachedState.explicitSubmittedPathState; } if (cachedState.wholeSubmittedPathState == null) { const semanticBudget = createMessageWorkBudget(budget, cachedState.messageSnapshot.content); const semanticState = getUserSubmittedPathState(cachedState.messageSnapshot, { includeExplicitPaths: false, budget: semanticBudget, capturedContent: cachedState.messageSnapshot.content, hasCapturedContent: true, capturedContentLength: cachedState.contentLength, capturedContentParts: cachedState.contentParts, }); if (semanticState.overflowed) { markProviderProjectionWorkOverflow(budget); } const paths: JsonPointer[] = []; const seen = new Set(); let overflowed = cachedState.explicitSubmittedPathState.overflowed || semanticState.overflowed; for (const state of [cachedState.explicitSubmittedPathState, semanticState]) { for (const path of state.paths) { if (seen.has(path)) { continue; } seen.add(path); if (seen.size > MAX_USER_SUBMITTED_PATHS) { overflowed = true; break; } paths.push(path); } } cachedState.wholeSubmittedPathState = { paths, overflowed }; } return cachedState.wholeSubmittedPathState; } function getSubmittedContentPartIndices( paths: readonly { readonly path?: string }[] | readonly string[], ): ReadonlySet { const indices = new Set(); for (let index = 0; index < paths.length; index++) { const candidate = paths[index]; const path = typeof candidate === 'string' ? candidate : candidate.path; if (typeof path !== 'string' || !path.startsWith('/')) { continue; } const segments = getSafeUserSubmittedPathSegments(path as JsonPointer); const encodedIndex = segments?.[1]; if ( segments?.[0] === 'content' && encodedIndex != null && /^\d+$/.test(encodedIndex) && String(Number(encodedIndex)) === encodedIndex ) { indices.add(Number(encodedIndex)); } } return indices; } function selectedPartsIntersect( selectedContentPartIndices: ReadonlySet | undefined, submittedContentPartIndices: ReadonlySet, ): boolean { if (selectedContentPartIndices == null) { return submittedContentPartIndices.size > 0; } for (const index of selectedContentPartIndices) { if (submittedContentPartIndices.has(index)) { return true; } } return false; } function getStoredProviderContributionState( selectedContentPartIndices: ReadonlySet | undefined, cachedState: CachedStoredProviderState, budget: ProviderProjectionWorkBudget, ): StoredProviderContributionState { const submittedPathState = getStoredSubmittedPathState( selectedContentPartIndices, cachedState, budget, ); let hasSelectedMaterial = selectedContentPartIndices == null; let hasSelectedSemanticPath = false; if (!hasSelectedMaterial && cachedState.contentLength != null) { const selectionBudget = createMessageWorkBudget(budget, cachedState.messageSnapshot.content); for (const index of selectedContentPartIndices ?? []) { if (!consumeProviderProjectionWork(selectionBudget, 1)) { break; } const part = readCachedStoredContentPart(cachedState, index, budget); if (part != null) { hasSelectedMaterial = true; hasSelectedSemanticPath ||= typeof part === 'object' && Object.prototype.hasOwnProperty.call(part, 'type') && (part as { readonly type?: unknown }).type === 'steer'; } } } cachedState.submittedContentPartIndices ??= getSubmittedContentPartIndices( submittedPathState.paths, ); cachedState.submittedFieldContentPartIndices ??= getSubmittedContentPartIndices( cachedState.submittedMessageFieldState.entries, ); const hasSelectedSubmittedPath = selectedContentPartIndices == null ? submittedPathState.paths.length > 0 : hasSelectedSemanticPath || selectedPartsIntersect(selectedContentPartIndices, cachedState.submittedContentPartIndices); const hasSelectedSubmittedField = selectedContentPartIndices == null ? cachedState.submittedMessageFieldState.entries.length > 0 : selectedPartsIntersect( selectedContentPartIndices, cachedState.submittedFieldContentPartIndices, ); const hasSubmittedCanonicalProvenance = hasSelectedSubmittedPath || hasSelectedSubmittedField || (hasSelectedMaterial && submittedPathState.overflowed); const storedRole = normalizeRole(cachedState.messageSnapshot); const isStoredUserSource = hasSelectedMaterial && (cachedState.messageSnapshot.isCreatedByUser === true || cachedState.messageSnapshot.isUserSubmitted === true || storedRole === 'user'); return { isCanonicalUserContribution: isStoredUserSource || hasSubmittedCanonicalProvenance, }; } function getSelectedRawStoredMessageFileIds( selectedContentPartIndices: ReadonlySet | undefined, cachedState: CachedStoredProviderState, budget: ProviderProjectionWorkBudget, ): ReadonlySet { if (selectedContentPartIndices == null) { if (cachedState.wholeRawFileIds != null) { return cachedState.wholeRawFileIds; } const fileIds = new Set(); const wasOverflowed = budget.overflowed; try { appendReferencedFileIds(fileIds, cachedState.messageSnapshot.files, budget); if (cachedState.contentLength != null) { const contentLength = cachedState.contentLength; const contentCount = Math.min(contentLength, MAX_PROVIDER_PROJECTION_WORK); const contentBudget = createMessageWorkBudget(budget, cachedState.messageSnapshot.content); for (let index = 0; index < contentCount; index++) { if (!consumeProviderProjectionWork(contentBudget, 1)) { break; } const part = readCachedStoredContentPart(cachedState, index, budget); if (part != null) { appendPartFileIds( fileIds, part as NonNullable[number]>, budget, ); } } if (contentLength > contentCount) { markProviderProjectionWorkOverflow(budget); } } } catch { markProviderProjectionWorkOverflow(budget); } if (!wasOverflowed && !budget.overflowed) { cachedState.wholeRawFileIds = fileIds; } return fileIds; } const fileIds = new Set(); try { if (cachedState.contentLength == null) { return fileIds; } const selectionBudget = createMessageWorkBudget(budget, cachedState.messageSnapshot.content); for (const index of selectedContentPartIndices) { if (!consumeProviderProjectionWork(selectionBudget, 1)) { break; } const part = readCachedStoredContentPart(cachedState, index, budget); if (part != null) { appendPartFileIds( fileIds, part as NonNullable[number]>, budget, ); } } } catch { markProviderProjectionWorkOverflow(budget); } return fileIds; } function appendMaterializedSelectedFileIds( target: Set, materializedFileIds: readonly string[] | undefined, rawSelectedFileIds: ReadonlySet, budget: ProviderProjectionWorkBudget, ): void { try { if (!Array.isArray(materializedFileIds)) { return; } const candidateCount = captureProviderArrayLength(materializedFileIds); let index = 0; for (; index < candidateCount; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } const candidate = materializedFileIds[index]; if (typeof candidate !== 'string') { continue; } const fileId = candidate.trim(); if (fileId.length > 0 && rawSelectedFileIds.has(fileId)) { target.add(fileId); } } if (index < candidateCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } } function appendLegacyMaterializedFileIds( target: Set, materializedFileIds: readonly string[] | undefined, budget: ProviderProjectionWorkBudget, ): void { try { if (!Array.isArray(materializedFileIds)) { return; } const candidateCount = captureProviderArrayLength(materializedFileIds); let index = 0; for (; index < candidateCount; index++) { if (!consumeProviderProjectionWork(budget, 1)) { break; } const fileId = materializedFileIds[index]; if (typeof fileId === 'string' && fileId.length > 0) { target.add(fileId); } } if (index < candidateCount) { markProviderProjectionWorkOverflow(budget); } } catch { markProviderProjectionWorkOverflow(budget); } } interface ModelBoundProviderContentIndex { readonly storedMessagesById: ReadonlyMap; readonly resolvedFilesById: ReadonlyMap; readonly storedStateByMessage: WeakMap; readonly overflowed: boolean; } function getCachedStoredProviderState( index: ModelBoundProviderContentIndex, message: StoredModelBoundMessage, parentBudget: ProviderProjectionWorkBudget, parentPartSnapshotBudget: ProviderProjectionWorkBudget, ): CachedStoredProviderState { const cached = index.storedStateByMessage.get(message); if (cached != null) { /** Cached snapshots outlive a model invocation; attach failures to the current budgets. */ cached.provenanceBudget.parent = parentBudget; if (cached.provenanceBudget.overflowed) { markProviderProjectionWorkOverflow(parentBudget); } cached.partSnapshotBudget.parent = parentPartSnapshotBudget; if (cached.partSnapshotBudget.overflowed) { markProviderProjectionWorkOverflow(parentPartSnapshotBudget); } return cached; } const budget = createMessageWorkBudget(parentBudget, undefined, MAX_PROVIDER_STORED_STATE_WORK); const partSnapshotBudget = createMessageWorkBudget(parentPartSnapshotBudget, undefined); let messageSnapshot: StoredModelBoundMessage = {}; try { messageSnapshot = { id: message.id, messageId: message.messageId, role: message.role, name: message.name, sender: message.sender, text: message.text, summary: message.summary, quotes: message.quotes, content: message.content, tool_calls: message.tool_calls, files: message.files, attachments: message.attachments, original: message.original, updated: message.updated, feedback: message.feedback, isCreatedByUser: message.isCreatedByUser, isUserSubmitted: message.isUserSubmitted, userSubmittedPaths: message.userSubmittedPaths, userSubmittedMessageFieldPaths: message.userSubmittedMessageFieldPaths, }; } catch { markProviderProjectionWorkOverflow(budget); } let contentLength: number | undefined; try { if (Array.isArray(messageSnapshot.content)) { contentLength = captureProviderArrayLength(messageSnapshot.content); } } catch { markProviderProjectionWorkOverflow(budget); contentLength = -1; } const contentParts = new Map(); const pathBudget = isProxy(messageSnapshot.userSubmittedPaths) || isProxy(messageSnapshot.userSubmittedMessageFieldPaths) ? parentBudget : budget; const provenanceOptions = { budget: pathBudget, capturedContent: messageSnapshot.content, hasCapturedContent: true, capturedContentLength: contentLength, capturedContentParts: contentParts, captureContentPart: (part: unknown) => snapshotModelBoundContentPart(part, partSnapshotBudget), }; const explicitSubmittedPathState = getUserSubmittedPathState(messageSnapshot, { ...provenanceOptions, includeSemanticContent: false, }); const submittedMessageFieldState = getUserSubmittedMessageFieldPathState( messageSnapshot, provenanceOptions, ); if (explicitSubmittedPathState.overflowed || pathBudget.overflowed) { markProviderProjectionWorkOverflow(budget); } const state: CachedStoredProviderState = { provenanceBudget: budget, messageSnapshot, contentLength, contentParts, partSnapshotBudget, explicitSubmittedPathState, submittedMessageFieldState, }; index.storedStateByMessage.set(message, state); return state; } function getExplicitStoredSubmittedPaths( cachedState: CachedStoredProviderState, ): ReadonlySet { if (cachedState.explicitSubmittedPaths != null) { return cachedState.explicitSubmittedPaths; } const explicitSubmittedPaths = new Set(cachedState.explicitSubmittedPathState.paths); cachedState.explicitSubmittedPaths = explicitSubmittedPaths; return explicitSubmittedPaths; } function createModelBoundProviderContentIndex( input: Pick, initiallyOverflowed = false, ): ModelBoundProviderContentIndex { const storedMessagesById = new Map(); let overflowed = initiallyOverflowed; try { const storedMessages = input.storedMessages; if (Array.isArray(storedMessages)) { const storedMessageLength = captureProviderArrayLength(storedMessages); const storedMessageCount = Math.min(storedMessageLength, MAX_PROVIDER_PROJECTION_WORK); overflowed ||= storedMessageLength > storedMessageCount; for (let index = 0; index < storedMessageCount; index++) { const message = storedMessages[index]; if (message == null) { continue; } for (const messageId of getStoredMessageIds(message)) { storedMessagesById.set(messageId, message); } } } } catch { overflowed = true; } const resolvedFilesById = new Map(); try { const resolvedFiles = input.resolvedFiles; if (Array.isArray(resolvedFiles)) { const resolvedFileLength = captureProviderArrayLength(resolvedFiles); const resolvedFileCount = Math.min(resolvedFileLength, MAX_PROVIDER_PROJECTION_WORK); overflowed ||= resolvedFileLength > resolvedFileCount; for (let index = 0; index < resolvedFileCount; index++) { const file = resolvedFiles[index]; if (typeof file?.file_id === 'string' && file.file_id.length > 0) { resolvedFilesById.set(file.file_id, file); } } } } catch { overflowed = true; } return { storedMessagesById, resolvedFilesById, storedStateByMessage: new WeakMap(), overflowed, }; } function createProviderProjectionWorkBudgets( index: ModelBoundProviderContentIndex, ): ProviderProjectionWorkBudgets { return { projection: { remaining: MAX_PROVIDER_PROJECTION_WORK, overflowed: index.overflowed, }, providerContent: { remaining: MAX_PROVIDER_PROJECTION_WORK, overflowed: index.overflowed, }, partSnapshot: { remaining: MAX_PROVIDER_PROJECTION_WORK, overflowed: index.overflowed, }, fileScan: { remaining: MAX_PROVIDER_PROJECTION_WORK, overflowed: index.overflowed, }, provenance: { remaining: MAX_PROVIDER_PROVENANCE_PARSE_WORK, overflowed: false, }, storedState: { remaining: MAX_PROVIDER_STORED_STATE_WORK, overflowed: false, }, nestedTraversal: { visitedNodes: 0, maxNodes: MAX_MODEL_BOUND_NESTED_TRAVERSAL_WORK, }, }; } function projectModelBoundProviderContent( input: ModelBoundProviderContentInput, index: ModelBoundProviderContentIndex, workBudgets = createProviderProjectionWorkBudgets(index), ): { storedMessages: StoredModelBoundMessage[]; resolvedFiles: ModelBoundCanonicalFile[]; deferredTraversalErrors: ContentTraversalLimitError[]; } { const selectedMessages: StoredModelBoundMessage[] = []; const selectedStoredMessages = new Set(); const selectedFileIds = new Set(); const deferredTraversalErrors: ContentTraversalLimitError[] = []; const projectionBudget = workBudgets.projection; const providerContentBudget = workBudgets.providerContent; const partSnapshotBudget = workBudgets.partSnapshot; const fileScanBudget = workBudgets.fileScan; const provenanceBudget = workBudgets.provenance; const storedStateBudget = workBudgets.storedState; const exactCanonicalSelections = new WeakMap>(); const exactFileSelections = new WeakMap>(); const exactContributionStates = new WeakMap< StoredModelBoundMessage, Map >(); const reportedExactFieldOverflows = new WeakSet(); const legacyFileSourceIds = new Set(); const appendExactFieldOverflow = ( message: StoredModelBoundMessage, cachedState: CachedStoredProviderState, ): void => { if ( !cachedState.submittedMessageFieldState.overflowed || reportedExactFieldOverflows.has(message) ) { return; } reportedExactFieldOverflows.add(message); deferredTraversalErrors.push( new ContentTraversalLimitError( [], [{ source: 'message', fields: [...HITL_MESSAGE_FILTER_FIELDS] }], ), ); }; const selectLegacyStoredMessage = ( message: StoredModelBoundMessage, cachedState: CachedStoredProviderState, ): void => { if (selectedStoredMessages.has(message)) { return; } selectedStoredMessages.add(message); appendExactFieldOverflow(message, cachedState); selectedMessages.push( projectStoredMessageForProvider( cachedState.messageSnapshot, projectionBudget, cachedState.partSnapshotBudget, undefined, undefined, cachedState.contentParts, cachedState.contentLength, cachedState.wholeSubmittedPathState?.paths ?? cachedState.explicitSubmittedPathState.paths, cachedState.submittedMessageFieldState.entries, ), ); }; const providerMessages: SnapshottedModelBoundProviderMessage[] = []; const providerRoles: Array = []; const providerContents: unknown[] = []; try { const providerMessageLength = captureProviderArrayLength(input.providerMessages); const providerMessageCount = Math.min(providerMessageLength, MAX_PROVIDER_PROJECTION_WORK); if (providerMessageLength > providerMessageCount) { markProviderProjectionWorkOverflow(projectionBudget); } for (let index = 0; index < providerMessageCount; index++) { const providerMessage = snapshotProviderMessageEnvelope( input.providerMessages[index], providerContentBudget, ); providerMessages.push(providerMessage); providerRoles.push(providerMessage.role); providerContents.push( snapshotProviderMessageContent(providerMessage, providerContentBudget, partSnapshotBudget), ); } } catch { markProviderProjectionWorkOverflow(projectionBudget); } for (let providerIndex = 0; providerIndex < providerMessages.length; providerIndex++) { const providerMessage = providerMessages[providerIndex]; const capturedProviderContent = providerContents[providerIndex]; const providerRole = providerRoles[providerIndex]; const provenanceState = getProviderMessageProvenanceState(providerMessage, provenanceBudget); let exactHasUserAttribution = false; let exactHasToolAttribution = false; if (provenanceState.orderedContributions != null) { const orderedContributions = provenanceState.orderedContributions; exactHasUserAttribution = orderedContributions.hasUserAttribution; exactHasToolAttribution = orderedContributions.hasToolAttribution; for (const contribution of orderedContributions.contributions) { const storedMessage = index.storedMessagesById.get(contribution.sourceMessageId); if (storedMessage == null) { continue; } const contentSelectionKey = getProviderContentSelectionKey( contribution.selectedContentPartIndices, ); const cachedState = getCachedStoredProviderState( index, storedMessage, storedStateBudget, partSnapshotBudget, ); appendExactFieldOverflow(storedMessage, cachedState); let contributionState = exactContributionStates .get(storedMessage) ?.get(contentSelectionKey); if (contributionState == null) { contributionState = getStoredProviderContributionState( contribution.selectedContentPartIndices, cachedState, storedStateBudget, ); const storedContributionStates = exactContributionStates.get(storedMessage); if (storedContributionStates == null) { exactContributionStates.set( storedMessage, new Map([[contentSelectionKey, contributionState]]), ); } else { storedContributionStates.set(contentSelectionKey, contributionState); } } exactHasUserAttribution ||= contributionState.isCanonicalUserContribution; const needsCanonicalProvenance = contribution.attribution === 'user' || contribution.attribution === 'tool' || contributionState.isCanonicalUserContribution || (input.filters?.messages?.unattributedAssistantContent === 'inspect' && providerRole === 'assistant'); if (needsCanonicalProvenance) { const exactAttribution = contribution.attribution === 'user' || contribution.attribution === 'tool' ? contribution.attribution : undefined; const selectionKey = `${exactAttribution ?? 'canonical'}:${contentSelectionKey}`; if (markUniqueStoredSelection(exactCanonicalSelections, storedMessage, selectionKey)) { selectedMessages.push( projectStoredMessageForProvider( cachedState.messageSnapshot, projectionBudget, cachedState.partSnapshotBudget, contribution.selectedContentPartIndices, exactAttribution, cachedState.contentParts, cachedState.contentLength, cachedState.explicitSubmittedPathState.paths, cachedState.submittedMessageFieldState.entries, ), ); } } if ( contribution.attribution === 'user' || contribution.attribution === 'tool' || contributionState.isCanonicalUserContribution ) { const fileSelectionKey = contentSelectionKey; if (markUniqueStoredSelection(exactFileSelections, storedMessage, fileSelectionKey)) { appendMaterializedSelectedFileIds( selectedFileIds, input.fileIdsBySourceMessageId?.get(contribution.sourceMessageId), getSelectedRawStoredMessageFileIds( contribution.selectedContentPartIndices, cachedState, fileScanBudget, ), fileScanBudget, ); } } } } else { const legacyLineage = getLegacyProviderLineage(providerMessage, provenanceBudget); const matchedStoredMessages = new Set(); let hasSubmittedCanonicalSource = false; for (const sourceId of legacyLineage.sourceIds) { const storedMessage = index.storedMessagesById.get(sourceId); if (storedMessage == null) { continue; } matchedStoredMessages.add(storedMessage); const cachedState = getCachedStoredProviderState( index, storedMessage, storedStateBudget, partSnapshotBudget, ); appendExactFieldOverflow(storedMessage, cachedState); const submittedPathState = getStoredSubmittedPathState( undefined, cachedState, storedStateBudget, ); const storedRole = normalizeRole(cachedState.messageSnapshot); const isStoredUserSource = cachedState.messageSnapshot.isCreatedByUser === true || cachedState.messageSnapshot.isUserSubmitted === true || storedRole === 'user'; const explicitPathMetadata = getCapturedUserSubmittedPathMetadata( cachedState.explicitSubmittedPathState, ); const hasStoredSubmittedProvenance = submittedPathState.overflowed || submittedPathState.paths.some( (path) => getExplicitStoredSubmittedPaths(cachedState).has(path) && !explicitPathMetadata.steerPaths.has(path), ) || cachedState.submittedMessageFieldState.entries.length > 0; hasSubmittedCanonicalSource ||= isStoredUserSource || hasStoredSubmittedProvenance; const needsCanonicalProvenance = isStoredUserSource || hasStoredSubmittedProvenance || providerRole === 'user' || (input.filters?.messages?.unattributedAssistantContent === 'inspect' && providerRole === 'assistant'); if (needsCanonicalProvenance) { selectLegacyStoredMessage(storedMessage, cachedState); } if (isStoredUserSource || hasStoredSubmittedProvenance || providerRole === 'user') { if (!legacyFileSourceIds.has(sourceId)) { legacyFileSourceIds.add(sourceId); appendLegacyMaterializedFileIds( selectedFileIds, input.fileIdsBySourceMessageId?.get(sourceId), fileScanBudget, ); } } } const lineageError = getLegacyCoalescedLineageError( input, providerRole, matchedStoredMessages, provenanceState, legacyLineage, ); if (lineageError != null) { deferredTraversalErrors.push(lineageError); } if (provenanceState.invalid) { for (const attribution of ['user', 'tool'] as const) { const projectedMessage = projectProviderMessage( providerMessage, attribution, capturedProviderContent, providerRole, partSnapshotBudget, ); selectedMessages.push(projectedMessage); appendStoredMessageFileIds( selectedFileIds, projectedMessage, input.filters, fileScanBudget, ); } continue; } const isLegacyArtifactHuman = isLegacyArtifactProjectionHuman( providerMessages, providerRoles, providerContents, providerIndex, provenanceState, legacyLineage, ); let projectedMessage = projectProviderMessage( providerMessage, isLegacyArtifactHuman ? 'tool' : undefined, capturedProviderContent, providerRole, partSnapshotBudget, ); if ( !isLegacyArtifactHuman && (providerRole === 'user' || providerRole === 'assistant') && hasSubmittedCanonicalSource ) { projectedMessage = { ...projectedMessage, isCreatedByUser: true, isUserSubmitted: true, }; } selectedMessages.push(projectedMessage); appendStoredMessageFileIds(selectedFileIds, projectedMessage, input.filters, fileScanBudget); continue; } /** Typed provenance is authoritative for attribution and source selection. * Cross-boundary payloads are inspected under every applicable external * source, while all-model/synthetic Human projections remain non-user. */ const exactAttributions: ProviderExactAttribution[] = []; if (exactHasUserAttribution) { exactAttributions.push('user'); } if (exactHasToolAttribution) { exactAttributions.push('tool'); } if (exactAttributions.length === 0) { exactAttributions.push('non_user'); } for (const attribution of exactAttributions) { const projectedMessage = projectProviderMessage( providerMessage, attribution, capturedProviderContent, providerRole, partSnapshotBudget, ); selectedMessages.push(projectedMessage); appendStoredMessageFileIds(selectedFileIds, projectedMessage, input.filters, fileScanBudget); } } const resolvedFiles: ModelBoundCanonicalFile[] = []; for (const fileId of selectedFileIds) { const file = index.resolvedFilesById.get(fileId); if (file != null) { resolvedFiles.push(file); } } if (selectedFileIds.size > 0) { selectedMessages.push({ role: 'user', isCreatedByUser: true, isUserSubmitted: true, files: [...selectedFileIds].map((file_id) => ({ file_id })), }); } if ( projectionBudget.overflowed || providerContentBudget.overflowed || fileScanBudget.overflowed || provenanceBudget.overflowed || storedStateBudget.overflowed ) { deferredTraversalErrors.push(new ContentTraversalLimitError()); } if (partSnapshotBudget.overflowed) { deferredTraversalErrors.push( new ContentTraversalLimitError([], getProviderPartSnapshotTraversalScopes(providerRoles)), ); } return { storedMessages: selectedMessages, resolvedFiles, deferredTraversalErrors }; } function assertIndexedModelBoundProviderContent( input: ModelBoundProviderContentInput, index: ModelBoundProviderContentIndex, workBudgets?: ProviderProjectionWorkBudgets, ): void { if (!hasModelBoundContentProtection(input.filters, input.legacyPii)) { return; } const resolvedWorkBudgets = workBudgets ?? createProviderProjectionWorkBudgets(index); const projection = projectModelBoundProviderContent(input, index, resolvedWorkBudgets); assertModelBoundContent({ onTraversalFailure: input.onTraversalFailure, filters: input.filters, legacyPii: input.legacyPii, privateTextTokens: input.privateTextTokens, storedMessages: projection.storedMessages, resolvedFiles: projection.resolvedFiles, deferredTraversalErrors: projection.deferredTraversalErrors, traversalBudget: resolvedWorkBudgets.nestedTraversal, }); } /** Inspects the exact provider selection while retaining persisted provenance. */ export function assertModelBoundProviderContent(input: ModelBoundProviderContentInput): void { assertIndexedModelBoundProviderContent( input, createModelBoundProviderContentIndex(input, input.sourceFileProjectionOverflowed === true), ); } function snapshotBoundedProviderArray(candidate: readonly T[] | undefined): { readonly values: T[]; readonly overflowed: boolean; } { const values: T[] = []; try { if (!Array.isArray(candidate)) { return { values, overflowed: candidate != null }; } const candidateCount = captureProviderArrayLength(candidate); const boundedCandidateCount = Math.min(candidateCount, MAX_PROVIDER_PROJECTION_WORK); for (let index = 0; index < boundedCandidateCount; index++) { values.push(candidate[index]); } return { values, overflowed: candidateCount > boundedCandidateCount }; } catch { return { values, overflowed: true }; } } function snapshotBoundedSourceFileIds( candidate: ReadonlyMap | undefined, ): { readonly values: Map; readonly overflowed: boolean } { const values = new Map(); let overflowed = false; let remaining = MAX_PROVIDER_PROJECTION_WORK; try { if (candidate == null) { return { values, overflowed }; } if (!(candidate instanceof Map)) { return { values, overflowed: true }; } const entries = Map.prototype.entries.call(candidate) as IterableIterator< [string, readonly string[]] >; let entryCount = 0; while (entryCount < MAX_PROVIDER_PROJECTION_WORK) { const next = entries.next(); if (next.done) { break; } const [sourceMessageId, fileIds] = next.value; entryCount++; if (!Array.isArray(fileIds)) { overflowed = true; continue; } const fileIdCount = captureProviderArrayLength(fileIds); const boundedFileIdCount = Math.min(fileIdCount, remaining); const copiedFileIds: string[] = []; for (let index = 0; index < boundedFileIdCount; index++) { copiedFileIds.push(fileIds[index]); } values.set(sourceMessageId, copiedFileIds); remaining -= boundedFileIdCount; if (fileIdCount > boundedFileIdCount) { overflowed = true; } } if (entryCount === MAX_PROVIDER_PROJECTION_WORK && !entries.next().done) { overflowed = true; } } catch { overflowed = true; } return { values, overflowed }; } /** Creates a run-stable callback shared by root, summary, and subagent model clients. */ export function createModelBoundChatModelCallback( input: Omit, options: { readonly onContentRejected?: (error: unknown) => void; readonly onContentAllowed?: (context: { runId?: string; parentRunId?: string; metadata?: Record; }) => void | Promise; } = {}, ): ModelBoundChatModelCallback { const storedMessageSnapshot = snapshotBoundedProviderArray(input.storedMessages); const resolvedFileSnapshot = snapshotBoundedProviderArray(input.resolvedFiles); const sourceFileIdSnapshot = snapshotBoundedSourceFileIds(input.fileIdsBySourceMessageId); const stableInput = { onTraversalFailure: input.onTraversalFailure, filters: input.filters, legacyPii: input.legacyPii, privateTextTokens: input.privateTextTokens, storedMessages: storedMessageSnapshot.values, resolvedFiles: resolvedFileSnapshot.values, fileIdsBySourceMessageId: sourceFileIdSnapshot.values, }; const index = createModelBoundProviderContentIndex( stableInput, storedMessageSnapshot.overflowed || resolvedFileSnapshot.overflowed || sourceFileIdSnapshot.overflowed || input.sourceFileProjectionOverflowed === true, ); const callback: ModelBoundChatModelCallback = Object.freeze({ name: 'librechat-model-bound-content-filter', raiseError: true, awaitHandlers: true, handleChatModelStart: ( _llm: object | undefined, messageBatches: readonly (readonly ModelBoundProviderMessage[])[], runId?: string, parentRunId?: string, _extraParams?: Record, _tags?: string[], metadata?: Record, ) => { let messageBatchCount = 0; let messageBatchesOverflowed = false; try { if (!Array.isArray(messageBatches)) { throw new TypeError('provider message batches must be an array'); } const messageBatchLength = captureProviderArrayLength(messageBatches); messageBatchCount = Math.min(messageBatchLength, MAX_PROVIDER_PROJECTION_WORK); messageBatchesOverflowed = messageBatchLength > messageBatchCount; } catch { const error = new ContentTraversalLimitError(); options.onContentRejected?.(error); throw new FatalModelBoundPolicyError(error); } const workBudgets = createProviderProjectionWorkBudgets(index); let remainingProviderMessages = MAX_PROVIDER_PROJECTION_WORK; for (let batchIndex = 0; batchIndex < messageBatchCount; batchIndex++) { try { const providerMessageCandidate = messageBatches[batchIndex]; if (!Array.isArray(providerMessageCandidate)) { throw new ContentTraversalLimitError(); } const providerMessageLength = captureProviderArrayLength(providerMessageCandidate); const providerMessageCount = Math.min(providerMessageLength, remainingProviderMessages); const providerMessages: ModelBoundProviderMessage[] = []; for (let index = 0; index < providerMessageCount; index++) { providerMessages.push(providerMessageCandidate[index]); } remainingProviderMessages -= providerMessageCount; assertIndexedModelBoundProviderContent( { ...stableInput, providerMessages, }, index, workBudgets, ); if (providerMessageCount < providerMessageLength) { throw new ContentTraversalLimitError(); } } catch (error) { if (error instanceof FatalModelBoundPolicyError) { throw error; } const policyError = isContentFilterError(error) ? error : new ContentTraversalLimitError(); options.onContentRejected?.(policyError); throw new FatalModelBoundPolicyError(policyError); } } if (messageBatchesOverflowed) { const error = new ContentTraversalLimitError(); options.onContentRejected?.(error); throw new FatalModelBoundPolicyError(error); } return options.onContentAllowed?.({ runId, parentRunId, metadata }); }, }); return callback; } /** * Holds a deferred parent write until every top-level starting agent clears * its first exact provider boundary and the corresponding model-node chain * completes. This callback belongs on the root RunnableConfig only: intrinsic * model callbacks intentionally propagate into subagents, whose reused agent * IDs must never satisfy a parent graph's admission barrier. */ export function createInitialModelBoundAdmissionCallback( admission: InitialModelBoundAdmission, ): InitialModelBoundAdmissionCallback { const pendingAgentIds = new Set( admission.agentIds .filter((agentId): agentId is string => typeof agentId === 'string') .map((agentId) => agentId.trim()) .filter((agentId) => agentId.length > 0), ); const chainParents = new Map(); const agentNodeRuns = new Map(); const modelRuns = new Map(); const successfulAgentNodeRuns = new Set(); let allowed = false; const isEligibleRootModel = ( metadata: Record | undefined, ): metadata is Record & { agentId: string } => { if (metadata?.summarization === true || typeof metadata?.agentId !== 'string') { return false; } const agentId = metadata.agentId.trim(); return pendingAgentIds.has(agentId) && metadata.langgraph_node === `agent=${agentId}`; }; const findAgentNodeRun = (parentRunId: string, agentId: string): string | undefined => { const visited = new Set(); let currentRunId: string | undefined = parentRunId; while (currentRunId != null && !visited.has(currentRunId)) { visited.add(currentRunId); if (agentNodeRuns.get(currentRunId) === agentId) { return currentRunId; } currentRunId = chainParents.get(currentRunId); } return undefined; }; const clearAgentNodeRun = (agentNodeRunId: string): void => { agentNodeRuns.delete(agentNodeRunId); successfulAgentNodeRuns.delete(agentNodeRunId); chainParents.delete(agentNodeRunId); for (const [modelRunId, nodeRunId] of modelRuns) { if (nodeRunId === agentNodeRunId) { modelRuns.delete(modelRunId); } } }; const callback: InitialModelBoundAdmissionCallback = { name: 'librechat-initial-model-bound-admission', raiseError: true, awaitHandlers: true, handleChainStart: (_chain, _inputs, runId, parentRunId, _tags, metadata, _runType, runName) => { if (typeof parentRunId === 'string') { chainParents.set(runId, parentRunId); } const nodeName = metadata?.langgraph_node; if (typeof nodeName !== 'string' || !nodeName.startsWith('agent=') || runName !== nodeName) { return; } const agentId = nodeName.slice('agent='.length).trim(); if (pendingAgentIds.has(agentId)) { agentNodeRuns.set(runId, agentId); } }, handleChatModelStart: ( _llm, _messageBatches, runId, parentRunId, _extraParams, _tags, metadata, ) => { if (allowed || !admission.isActive() || !isEligibleRootModel(metadata)) { return; } if (typeof runId !== 'string' || typeof parentRunId !== 'string') { return; } const agentNodeRunId = findAgentNodeRun(parentRunId, metadata.agentId.trim()); if (agentNodeRunId != null) { modelRuns.set(runId, agentNodeRunId); } }, handleLLMEnd: (_output, runId) => { const agentNodeRunId = modelRuns.get(runId); if (agentNodeRunId == null) { return; } modelRuns.delete(runId); successfulAgentNodeRuns.add(agentNodeRunId); }, handleLLMError: (_error, runId) => { modelRuns.delete(runId); }, handleChainEnd: (outputs, runId) => { chainParents.delete(runId); const agentId = agentNodeRuns.get(runId); const modelNodeOutput = outputs != null && typeof outputs === 'object' ? (outputs as { messages?: unknown; summarizationRequest?: unknown }) : undefined; const hasCompletedModelResult = Array.isArray(modelNodeOutput?.messages) && modelNodeOutput.messages.length > 0 && modelNodeOutput.summarizationRequest == null; const hasSuccessfulAttempt = successfulAgentNodeRuns.has(runId); if (agentId != null) { clearAgentNodeRun(runId); } if ( agentId == null || !hasSuccessfulAttempt || !hasCompletedModelResult || allowed || !admission.isActive() || !pendingAgentIds.delete(agentId) ) { return; } if (pendingAgentIds.size === 0) { allowed = true; admission.onAllowed(); } }, handleChainError: (_error, runId) => { chainParents.delete(runId); if (agentNodeRuns.has(runId)) { clearAgentNodeRun(runId); } }, }; return Object.freeze(callback); } /** * Re-inspects the final model-bound representation. This makes a newly * enabled or tightened policy apply to persisted messages and reusable * agent/skill/memory/file context, not only to the request that created it. */ export function assertModelBoundContent(input: ModelBoundContentInput): void { const inspector = createConfiguredContentInspector({ filters: input.filters, legacyPii: input.legacyPii, }); if (inspector?.hasAuditRules !== true) { inspectModelBoundContent(input, inspector); return; } aggregateAuditFindingsSync(() => inspectModelBoundContent(input, inspector)); } function inspectModelBoundContent( input: ModelBoundContentInput, inspector: ConfiguredContentInspector | null, ): void { const hasFileFailClose = getBlockedUninspectableFileField(input.filters, FILE_FILTER_FIELDS) != null; if (inspector == null && !hasFileFailClose) { return; } const inspectionSession = inspector?.createSession(); const shouldContinueAfterFinding = inspectionSession?.hasAuditRules === true; let finding: ReturnType['inspect']> = null; const inspectFragment = (fragment: TextContentFragment): void => { if (finding != null && !shouldContinueAfterFinding) { return; } const inspectableText = input.privateTextTokens?.size && (fragment.source === 'message' || fragment.source === 'assembled_context') ? fragment.text.replace( /\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]/g, (token) => (input.privateTextTokens!.has(token) ? '' : token), ) : fragment.text; const inspected = inspectableText === fragment.text ? fragment : { ...fragment, text: inspectableText }; const nextFinding = inspectionSession?.inspectFragment(inspected) ?? null; finding ??= nextFinding; }; const inspectFragments = (fragments: Iterable): void => { for (const fragment of fragments) { inspectFragment(fragment); if (finding != null && !shouldContinueAfterFinding) { return; } } }; const traversalErrors: ContentTraversalLimitError[] = [ ...(input.deferredTraversalErrors ?? []), ].filter((error) => { // Unscoped errors come from pre-existing fail-closed projection limits. // New part-snapshot errors describe exactly what they could not capture, // so only those use the selected-policy gate. if (getContentTraversalScopes(error).length === 0) { return true; } return isContentTraversalProtected({ error, filters: input.filters, legacyPii: input.legacyPii, }); }); const storedMessageTraversalBudget = input.traversalBudget ?? { visitedNodes: 0, maxNodes: MAX_MODEL_BOUND_NESTED_TRAVERSAL_WORK, }; const appendExtractedContent = (extract: () => readonly TextContentFragment[]) => { try { inspectFragments(extract()); } catch (error) { if (!isContentTraversalLimitError(error)) { throw error; } inspectFragments(getContentTraversalFragments(error)); if ( isContentTraversalProtected({ error, filters: input.filters, legacyPii: input.legacyPii, }) ) { traversalErrors.push(error); } } }; const resolvedFilesById = new Map(); const appendFile = ( file: FileContentInput | string | null | undefined, ): ModelBoundCanonicalFile | undefined => { if (file == null) { return undefined; } const isHydratedCanonicalFile = typeof file === 'object' && typeof (file as { file_id?: unknown }).file_id === 'string' && (file as { file_id: string }).file_id.length > 0; if (isHydratedCanonicalFile) { assertHydratedFileInspectable(input.filters, file); assertInspectableFileInput(allowHydratedFileReferences(input.filters), file); } else { assertInspectableFileInput(input.filters, file); } inspectFragments( extractFileContent(typeof file === 'string' ? { content: file, text: file } : file), ); return isHydratedCanonicalFile ? (file as ModelBoundCanonicalFile) : undefined; }; for (const file of input.resolvedFiles ?? []) { const resolvedFile = appendFile(file); if (resolvedFile?.file_id != null) { resolvedFilesById.set(resolvedFile.file_id, resolvedFile); } } if (input.submittedMessages != null) { const preparedSubmittedMessages = snapshotExternalMessages( input.submittedMessages, storedMessageTraversalBudget, ); assertInspectableFileInput(input.filters, preparedSubmittedMessages.messages); const appendSubmittedTraversalError = (error: ContentTraversalLimitError): void => { const hasExplicitScopes = getContentTraversalScopes(error).length > 0; const isProtected = isContentTraversalProtected({ error, filters: input.filters, legacyPii: input.legacyPii, roles: preparedSubmittedMessages.roles, }); if ( isProtected && (hasExplicitScopes || isNestedMessageTraversalProtected({ filters: input.filters, legacyPii: input.legacyPii, roles: preparedSubmittedMessages.roles, })) ) { traversalErrors.push(error); } }; try { for (const fragment of extractMessageContent(preparedSubmittedMessages)) { inspectFragment(fragment); } } catch (error) { if (!isContentTraversalLimitError(error)) { throw error; } inspectFragments(getContentTraversalFragments(error)); appendSubmittedTraversalError(error); } } let aggregateStoredTraversalErrorAdded = false; const appendStoredTraversalError = (error: ContentTraversalLimitError): void => { if ( storedMessageTraversalBudget.visitedNodes >= (storedMessageTraversalBudget.maxNodes ?? CONTENT_TRAVERSAL_MAX_NODES) || (storedMessageTraversalBudget.materializedCharacters ?? 0) >= (storedMessageTraversalBudget.maxMaterializedCharacters ?? CONTENT_MATERIALIZATION_MAX_CHARACTERS) ) { if (aggregateStoredTraversalErrorAdded) { return; } aggregateStoredTraversalErrorAdded = true; } traversalErrors.push(error); }; for (const message of input.storedMessages ?? []) { /** Structural limits belong to the message; assembled-text allocations remain request-wide. */ const messageTraversalBudget: VisitNestedStringsBudget = { visitedNodes: 0, maxNodes: MAX_MODEL_BOUND_NESTED_TRAVERSAL_WORK, get materializedCharacters() { return storedMessageTraversalBudget.materializedCharacters; }, set materializedCharacters(value: number | undefined) { storedMessageTraversalBudget.materializedCharacters = value; }, maxMaterializedCharacters: storedMessageTraversalBudget.maxMaterializedCharacters, }; const submittedPathState = getUserSubmittedPathState(message); const submittedMessageFieldState = getUserSubmittedMessageFieldPathState(message); const semanticUserSubmittedPaths = submittedMessageFieldState.entries.map( (entry) => entry.path as JsonPointer, ); const effectiveUserSubmittedPaths = [ ...new Set([...submittedPathState.paths, ...semanticUserSubmittedPaths]), ]; const isUnattributedAssistant = input.filters?.messages?.unattributedAssistantContent === 'inspect' && typeof message.isUserSubmitted !== 'boolean' && effectiveUserSubmittedPaths.length === 0 && (message.isCreatedByUser === false || normalizeRole(message) === 'assistant'); const isEntireMessageUserSubmitted = message?.isCreatedByUser === true || message?.isUserSubmitted === true || submittedPathState.overflowed || isUnattributedAssistant; let messageFragments: readonly TextContentFragment[]; let traversalError: ContentTraversalLimitError | null = null; try { messageFragments = extractStoredMessageContent(message, messageTraversalBudget); } catch (error) { if (!isContentTraversalLimitError(error)) { throw error; } traversalError = error; messageFragments = getContentTraversalFragments(error); } const exactMessageFields = [ ...new Set(submittedMessageFieldState.entries.map((entry) => entry.field)), ]; const shouldInspectExactMessageFields = hasActivePiiPatterns(input.legacyPii) || hasActivePiiFields(input.filters?.messages?.pii, exactMessageFields); let exactMessageFragments: Array> = []; let exactMessageTraversalError: ContentTraversalLimitError | null = null; if (shouldInspectExactMessageFields) { if (traversalError == null) { exactMessageFragments = getExactUserSubmittedMessageFragments( messageFragments, submittedMessageFieldState.entries, ); } else { const exactMessageInspection = extractExactUserSubmittedMessageFragments( message, submittedMessageFieldState.entries, messageTraversalBudget, ); exactMessageFragments = exactMessageInspection.fragments; exactMessageTraversalError = exactMessageInspection.traversalError; } } if (exactMessageTraversalError != null && shouldInspectExactMessageFields) { appendStoredTraversalError( new ContentTraversalLimitError([], [{ source: 'message', fields: exactMessageFields }]), ); } if ( submittedMessageFieldState.overflowed && (hasActivePiiPatterns(input.legacyPii) || hasActivePiiFields(input.filters?.messages?.pii, HITL_MESSAGE_FILTER_FIELDS)) ) { traversalErrors.push( new ContentTraversalLimitError( [], [{ source: 'message', fields: [...HITL_MESSAGE_FILTER_FIELDS] }], ), ); } if (!isEntireMessageUserSubmitted) { const userSubmittedPaths = submittedPathState.paths; const projectedMessage = projectUserSubmittedPaths(message, effectiveUserSubmittedPaths); if (projectedMessage != null) { assertInspectableFileInput( input.filters, omitResolvedCanonicalFileLocators(projectedMessage, resolvedFilesById, { messageCount: input.storedMessages?.length ?? 0, onTraversalFailure: input.onTraversalFailure, }), ); } /** Legacy unmarked assistant rows are treated as model-generated by * default. Strict attribution can inspect an otherwise unattributed * assistant row as submitted content. Structured tool calls/results * remain externally sourced model-bound content. Explicit paths and * semantic steer parts identify user-authored fragments in mixed rows. */ if (finding == null || shouldContinueAfterFinding) { const submittedPathSet = new Set(userSubmittedPaths); for (const fragment of messageFragments) { if (fragment.source === 'tool_argument') { inspectFragment(fragment); if (finding != null && !shouldContinueAfterFinding) { break; } } } if (finding == null || shouldContinueAfterFinding) { const submittedToolOutputs: Array< Extract > = []; const assembledText: string[] = []; for (const fragment of messageFragments) { if (!isFragmentWithinSubmittedPaths(fragment, submittedPathSet)) { continue; } if (fragment.source !== 'tool_argument') { inspectFragment(fragment); if (finding != null && !shouldContinueAfterFinding) { break; } } if ( fragment.source === 'message' && (fragment.field === 'text' || fragment.field === 'content_part') ) { assembledText.push(fragment.text); } else if (fragment.source === 'tool_argument' && fragment.field === 'output') { submittedToolOutputs.push(fragment); assembledText.push(fragment.text); } } if (finding == null || shouldContinueAfterFinding) { for (const fragment of submittedToolOutputs) { inspectFragment(asUserSubmittedMessageFragment(fragment)); if (finding != null && !shouldContinueAfterFinding) { break; } } } if (finding == null || shouldContinueAfterFinding) { inspectFragments(exactMessageFragments); } if ( (finding == null || shouldContinueAfterFinding) && (hasActivePiiPatterns(input.legacyPii) || hasActivePiiFields(input.filters?.messages?.pii, ['assembled_context'])) ) { const userSubmittedAssembledContext = createUserSubmittedAssembledContext( assembledText, messageTraversalBudget, ); if (userSubmittedAssembledContext.fragment != null) { inspectFragment(userSubmittedAssembledContext.fragment); } if (userSubmittedAssembledContext.overflowed) { appendStoredTraversalError( new ContentTraversalLimitError( [], [{ source: 'assembled_context', fields: ['assembled_context'] }], ), ); } } } } if (traversalError != null) { let traversalFilters = input.filters; if (userSubmittedPaths.length === 0 && traversalFilters != null) { traversalFilters = { ...traversalFilters, messages: undefined }; } if ( isContentTraversalProtected({ error: traversalError, filters: traversalFilters, legacyPii: userSubmittedPaths.length > 0 ? input.legacyPii : undefined, roles: userSubmittedPaths.length > 0 ? ['user'] : [message.role], }) ) { appendStoredTraversalError(traversalError); } } continue; } assertInspectableFileInput( input.filters, omitResolvedCanonicalFileLocators(message, resolvedFilesById, { messageCount: input.storedMessages?.length ?? 0, onTraversalFailure: input.onTraversalFailure, }), ); inspectFragments(messageFragments); inspectFragments(exactMessageFragments); if ( traversalError != null && isContentTraversalProtected({ error: traversalError, filters: input.filters, legacyPii: input.legacyPii, roles: [message.role ?? 'user'], }) ) { appendStoredTraversalError(traversalError); } } for (const agent of input.agents ?? []) { const agentFilesById = new Map(); for (const file of getHydratedAgentFiles(agent)) { const resolvedFile = appendFile(file); if (resolvedFile?.file_id != null) { agentFilesById.set(resolvedFile.file_id, resolvedFile); } } assertInspectableFileInput( input.filters, omitResolvedCanonicalFileLocators(agent, agentFilesById, { onTraversalFailure: input.onTraversalFailure, messageCount: input.storedMessages?.length ?? 0, }), ); appendExtractedContent(() => extractAgentContent(agent)); } for (const assistant of input.assistants ?? []) { assertInspectableFileInput(input.filters, assistant); appendExtractedContent(() => extractAssistantContent(assistant)); } for (const action of input.actions ?? []) { appendExtractedContent(() => extractAssistantActionContent(action)); } for (const skill of input.skills ?? []) { appendExtractedContent(() => extractSkillContent(skill)); } for (const memory of input.memories ?? []) { inspectFragments(extractMemoryContent(typeof memory === 'string' ? { value: memory } : memory)); } for (const file of input.files ?? []) { appendFile(file); } if (finding != null) { throw new ContentFilterError(finding); } if (traversalErrors.length > 0) { throw traversalErrors[0]; } }