@vertesia/ui 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260804.124748Z

package/src/features/agent/chat/ModernAgentOutput/requestInputMessages.test.ts

@@ -1,9 +1,16 @@
 import { type AgentMessage, AgentMessageType } from '@vertesia/common';
 import { describe, expect, it } from 'vitest';
 import {
+    clearRequestInputIdAnsweredForSession,
+    getAnsweredRequestInputKeys,
     getAnsweredToolApprovalRequestInputKeys,
+    getPendingRequestInputMessage,
     getRequestInputMessageKey,
+    getRequestInputResponseIdFromMetadata,
+    getRequestInputResponseMetadata,
     getToolApprovalResponseMetadata,
+    isRequestInputAnsweredForSession,
+    markRequestInputIdAnsweredForSession,
 } from './requestInputMessages';
 
 const APPROVAL_KEY = 'create_interaction:name:JDE AR Payment Processing Agent';
@@ -78,3 +85,91 @@ describe('getAnsweredToolApprovalRequestInputKeys', () => {
         expect(answered.size).toBe(0);
     });
 });
+
+describe('request input correlation', () => {
+    it('does not apply session acknowledgement to non-request-input messages with the same id', () => {
+        const agentRunId = 'agent-run-1';
+        const requestId = 'request-1';
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: requestId, ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const unrelatedMessage = {
+            ...makeUserAnswer('Still working'),
+            details: { request_id: requestId },
+        };
+
+        markRequestInputIdAnsweredForSession(agentRunId, requestId);
+
+        expect(isRequestInputAnsweredForSession(agentRunId, request)).toBe(true);
+        expect(isRequestInputAnsweredForSession(agentRunId, unrelatedMessage)).toBe(false);
+
+        clearRequestInputIdAnsweredForSession(agentRunId, requestId);
+    });
+
+    it('correlates a persisted response to the matching request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 2,
+            details: { request_id: 'request-2', ux: { options: [{ id: 'blue', label: 'Blue' }] } },
+        };
+        const answer = {
+            ...makeUserAnswer('red'),
+            timestamp: 3,
+            details: { request_input_response: { request_id: 'request-1' } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, secondRequest, answer]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, secondRequest, answer])).toBe(secondRequest);
+    });
+
+    it('adds the request id without discarding existing response metadata', () => {
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+
+        expect(getRequestInputResponseMetadata(request, { source: 'free-response' })).toEqual({
+            source: 'free-response',
+            request_input_response: { request_id: 'request-1' },
+        });
+    });
+
+    it('does not let an earlier response resolve a later prompt that reused its request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const firstAnswer = {
+            ...makeUserAnswer('allow_once'),
+            details: { request_input_response: { request_id: 'reused-request' } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 3,
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, firstAnswer, secondRequest]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, firstAnswer, secondRequest])).toBe(secondRequest);
+    });
+
+    it('reads a request id from response metadata', () => {
+        expect(
+            getRequestInputResponseIdFromMetadata({
+                request_input_response: { request_id: 'request-1' },
+            }),
+        ).toBe('request-1');
+        expect(getRequestInputResponseIdFromMetadata({ request_input_response: {} })).toBeUndefined();
+    });
+});

package/src/features/agent/chat/ModernAgentOutput/requestInputMessages.ts

@@ -96,6 +96,65 @@ export function getRequestInputMessageKey(message: AgentMessage): string {
         .join('|');
 }
 
+export function getRequestInputId(message: AgentMessage): string | undefined {
+    const details = message.details as Record<string, unknown> | undefined;
+    const requestId = details?.request_id ?? details?.tool_use_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
+export function getRequestInputResolutionKey(message: AgentMessage): string {
+    return getRequestInputId(message) ?? getRequestInputMessageKey(message);
+}
+
+const ANSWERED_REQUEST_INPUT_STORAGE_PREFIX = 'vertesia:answered-request-input:';
+
+function getAnsweredRequestInputStorageKey(agentRunId: string, requestId: string): string {
+    return `${ANSWERED_REQUEST_INPUT_STORAGE_PREFIX}${agentRunId}:${requestId}`;
+}
+
+export function markRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.setItem(getAnsweredRequestInputStorageKey(agentRunId, requestId), '1');
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function clearRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.removeItem(getAnsweredRequestInputStorageKey(agentRunId, requestId));
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function isRequestInputAnsweredForSession(agentRunId: string, message: AgentMessage): boolean {
+    if (message.type !== AgentMessageType.REQUEST_INPUT) return false;
+
+    const requestId = getRequestInputId(message);
+    if (!requestId || typeof window === 'undefined') return false;
+
+    try {
+        return window.sessionStorage.getItem(getAnsweredRequestInputStorageKey(agentRunId, requestId)) === '1';
+    } catch {
+        return false;
+    }
+}
+
+function getRequestInputResponseId(message: AgentMessage): string | undefined {
+    if (message.type !== AgentMessageType.QUESTION) return undefined;
+
+    const details = getRecord(message.details);
+    const metadata = getRecord(details?.metadata);
+    const response = getRecord(details?.request_input_response) ?? getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
     const details = message.details as Record<string, unknown> | undefined;
     const keyParts = [
@@ -114,10 +173,22 @@ export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
 
 export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<string> {
     const answered = new Set<string>();
+    const latestResponseIndexByRequestId = new Map<string, number>();
+    messages.forEach((message, index) => {
+        const requestId = getRequestInputResponseId(message);
+        if (requestId) latestResponseIndexByRequestId.set(requestId, index);
+    });
 
     messages.forEach((message, index) => {
         if (message.type !== AgentMessageType.REQUEST_INPUT) return;
 
+        const requestId = getRequestInputId(message);
+        const correlatedResponseIndex = requestId ? latestResponseIndexByRequestId.get(requestId) : undefined;
+        if (correlatedResponseIndex !== undefined && correlatedResponseIndex > index) {
+            answered.add(getRequestInputMessageKey(message));
+            return;
+        }
+
         const workstreamId = getWorkstreamId(message);
         for (let nextIndex = index + 1; nextIndex < messages.length; nextIndex += 1) {
             const nextMessage = messages[nextIndex];
@@ -125,7 +196,9 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
 
             if (nextMessage.type === AgentMessageType.REQUEST_INPUT) break;
             if (nextMessage.type === AgentMessageType.QUESTION) {
-                answered.add(getRequestInputMessageKey(message));
+                if (!getRequestInputResponseId(nextMessage)) {
+                    answered.add(getRequestInputMessageKey(message));
+                }
                 break;
             }
         }
@@ -134,6 +207,41 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
     return answered;
 }
 
+export function getRequestInputResponseMetadata(
+    message: AgentMessage,
+    metadata?: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+    const requestId = getRequestInputId(message);
+    if (!requestId) return metadata;
+
+    return {
+        ...metadata,
+        request_input_response: { request_id: requestId },
+    };
+}
+
+export function sendRequestInputResponse(
+    onSendMessage: ((message: string, metadata?: Record<string, unknown>) => void) | undefined,
+    requestMessage: AgentMessage,
+    response: string,
+    metadata?: Record<string, unknown>,
+): void {
+    if (!onSendMessage) return;
+
+    const responseMetadata = getRequestInputResponseMetadata(requestMessage, metadata);
+    if (responseMetadata) {
+        onSendMessage(response, responseMetadata);
+    } else {
+        onSendMessage(response);
+    }
+}
+
+export function getRequestInputResponseIdFromMetadata(metadata?: Record<string, unknown>): string | undefined {
+    const response = getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getResolvedToolApprovalKeys(messages: AgentMessage[]): Set<string> {
     const resolved = new Set<string>();
 
@@ -300,6 +408,7 @@ export function isRequestInputAnswered(message: AgentMessage, answeredRequestInp
 export function getPendingRequestInputMessage(
     messages: AgentMessage[],
     workstreamId = 'main',
+    locallyAnsweredRequestInputKeys?: ReadonlySet<string>,
 ): RequestInputMessageWithUx | undefined {
     const answeredRequestInputKeys = getAnsweredRequestInputKeys(messages);
     const resolvedToolApprovalKeys = getResolvedToolApprovalKeys(messages);
@@ -308,6 +417,7 @@ export function getPendingRequestInputMessage(
         const message = messages[index];
         if (!hasRequestInputUx(message)) continue;
         if (getWorkstreamId(message) !== workstreamId) continue;
+        if (locallyAnsweredRequestInputKeys?.has(getRequestInputResolutionKey(message))) continue;
         if (isRequestInputAnswered(message, answeredRequestInputKeys)) continue;
         if (isRequestInputResolvedByToolApprovalEvent(message, resolvedToolApprovalKeys)) continue;
         return message;

package/src/features/agent/chat/hooks/useAgentStream.test.tsx

@@ -312,6 +312,63 @@ describe('useAgentStream', () => {
         expect(onMessage).toHaveBeenCalledTimes(1);
     });
 
+    it('does not apply replayed file_processing snapshots to server file updates', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const historical = fileSnapshot(1_000, 'old-upload');
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            options?.onHistoryLoaded?.([historical]);
+            // Completed runs replay archived file_processing snapshots through the
+            // live callback; applying them would rehydrate every historical upload
+            // as a staged composer chip on reopen.
+            onMessage?.(historical);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1', vi.fn()));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        expect(result.current.serverFileUpdates.size).toBe(0);
+
+        act(() => deliver?.(fileSnapshot(1_100, 'new-upload')));
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('new-upload')).toBe(true);
+    });
+
     it('marks initial history as errored when the history fetch fails', async () => {
         const streamMessages = vi.fn<
             (

package/src/features/agent/chat/hooks/useAgentStream.ts

@@ -357,9 +357,12 @@ export function useAgentStream(
                 (message) => {
                     if (abortController.signal.aborted) return;
                     // Completed and idle runs replay their archived history through the live
-                    // stream. Only forward genuinely new deliveries so onMessage consumers
+                    // stream. Track replay status once, before the cursor advances below —
+                    // every replay-sensitive consumer in this callback must use it.
+                    const isReplay = Boolean(message.timestamp && message.timestamp <= lastDeliveredTsRef.current);
+                    // Only forward genuinely new deliveries so onMessage consumers
                     // never treat replayed events as fresh ones.
-                    if (!message.timestamp || message.timestamp > lastDeliveredTsRef.current) {
+                    if (!isReplay) {
                         onMessageRef.current?.(message);
                     }
 
@@ -426,7 +429,13 @@ export function useAgentStream(
                     if (message.type === AgentMessageType.SYSTEM) {
                         const details = message.details as FileProcessingDetails | undefined;
                         if (details?.system_type === 'file_processing' && details.files) {
-                            setServerFileUpdates(new Map(details.files.map((file) => [file.id, file])));
+                            // Replayed snapshots list every file ever uploaded to the run as
+                            // READY; applying them on reconnect would rehydrate historical
+                            // uploads as staged composer chips. Only genuinely new updates
+                            // may touch the file state.
+                            if (!isReplay) {
+                                setServerFileUpdates(new Map(details.files.map((file) => [file.id, file])));
+                            }
                             return;
                         }
                         // Other SYSTEM messages fall through to normal handling

package/src/features/agent/chat/index.ts

@@ -39,6 +39,7 @@ export {
 } from './AskUserWidget';
 export * from './JumpingDots';
 export {
+    type AgentMessageFilter,
     ModernAgentConversation,
     type ModernAgentConversationProps,
     type SendAgentMessageFn,

package/src/features/facets/PromptsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { FacetBucket } from '@vertesia/common';
+import type { ComputedFacetResponse, FacetBucket } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     FilterBar,
@@ -11,11 +11,13 @@ import { useState } from 'react';
 import { filterValueToQueryValue, type SearchInterface, setSearchQueryValue } from './utils/SearchInterface';
 
 interface PromptsFacetsNavProps {
-    facets: {
-        role?: FacetBucket[];
-        status?: FacetBucket[];
-        tags?: FacetBucket[];
-    };
+    /**
+     * The facet response as the endpoint publishes it: `total` plus one entry per facet the caller
+     * asked for. The names are chosen per request, so the buckets are narrowed below rather than
+     * declared here — the previous `{ role, status, tags }` shape named facets this component never
+     * requests and could not describe a caller that asks for a different one.
+     */
+    facets: ComputedFacetResponse;
     search: SearchInterface;
     /**
      * Optional controlled filter state. When provided, the parent owns the filter list (and is
@@ -28,8 +30,14 @@ interface PromptsFacetsNavProps {
     filterGroups?: FilterGroup[];
 }
 
+function facetBuckets(facets: ComputedFacetResponse, name: string): FacetBucket[] {
+    const value = facets[name];
+    return Array.isArray(value) ? (value as FacetBucket[]) : [];
+}
+
 // Hook to create filter groups for prompts
 export function usePromptsFilterGroups(facets: PromptsFacetsNavProps['facets']): FilterGroup[] {
+    const roleBuckets = facetBuckets(facets, 'role');
     const customFilterGroups: FilterGroup[] = [];
 
     // Add name filter as text type
@@ -42,12 +50,12 @@ export function usePromptsFilterGroups(facets: PromptsFacetsNavProps['facets']):
     customFilterGroups.push(nameFilterGroup);
 
     // Add role filter as select type if role facets are available
-    if (facets.role && facets.role.length > 0) {
+    if (roleBuckets.length > 0) {
         const rolesFilterGroup = {
             name: 'role',
             placeholder: 'Role',
             type: 'select' as const,
-            options: facets.role.map((facet) => ({
+            options: roleBuckets.map((facet) => ({
                 label: facet._id,
                 value: facet._id,
                 count: facet.count,
@@ -62,7 +70,7 @@ export function usePromptsFilterGroups(facets: PromptsFacetsNavProps['facets']):
         placeholder: 'Tags',
         type: 'stringList' as const,
         multiple: true,
-        options: (facets.tags ?? []).map((facet) => ({
+        options: facetBuckets(facets, 'tags').map((facet) => ({
             label: facet._id,
             value: facet._id,
         })),

package/src/features/store/objects/components/ContentOverview.tsx

@@ -843,7 +843,10 @@ function TextActions({
         () => (project ? client.projects.retrieve(project.id) : Promise.resolve(undefined)),
         [project?.id],
     );
-    const pdfTemplateObjectId = fullProject?.configuration?.pdf_template_object_id;
+    // `null` is how the setting is cleared, and it means the same thing here as an absent value: no
+    // custom template, so the export falls back to the built-in one. Collapsing the two spellings at
+    // the read keeps `templateObjectId` below a plain optional string.
+    const pdfTemplateObjectId = fullProject?.configuration?.pdf_template_object_id ?? undefined;
 
     const isMarkdown = isMarkdownContentType(content?.type);
     const isDocumentEditingContent = isDocumentEditingContentType(content?.type);

package/src/features/store/objects/selection/ObjectsActionContext.tsx

@@ -1,4 +1,4 @@
-import type { ContentObjectTypeItem } from '@vertesia/common';
+import type { ContentObjectTypeCatalogEntry } from '@vertesia/common';
 import { useToast } from '@vertesia/ui/core';
 import { useUserSession } from '@vertesia/ui/session';
 import { type ReactNode, useMemo } from 'react';
@@ -25,7 +25,7 @@ const DEFAULT_ACTIONS: ObjectsActionSpec[] = [
 
 interface ObjectsActionContextProps {
     children: ReactNode;
-    type?: ContentObjectTypeItem;
+    type?: ContentObjectTypeCatalogEntry;
 }
 export function ObjectsActionContextProvider({ children, type }: ObjectsActionContextProps) {
     const selection = useDocumentSelection();

package/src/features/store/objects/selection/ObjectsActionSpec.ts

@@ -1,5 +1,5 @@
 import type { VertesiaClient } from '@vertesia/client';
-import type { ColumnLayout, ContentObjectTypeItem } from '@vertesia/common';
+import type { ColumnLayout, ContentObjectTypeCatalogEntry } from '@vertesia/common';
 import type { ToastFn } from '@vertesia/ui/core';
 import type { DocumentSelection } from '../DocumentSelectionProvider';
 import type { DocumentSearch } from '../search/DocumentSearchContext';
@@ -22,7 +22,7 @@ export interface ObjectsActionParams {
     toast: ToastFn;
     search: DocumentSearch;
     table_layout?: ColumnLayout[];
-    type?: ContentObjectTypeItem;
+    type?: ContentObjectTypeCatalogEntry;
 }
 
 export interface ActionComponentTypeProps {

package/src/features/store/objects/selection/SelectionActions.tsx

@@ -1,4 +1,4 @@
-import type { ContentObjectTypeItem } from '@vertesia/common';
+import type { ContentObjectTypeCatalogEntry } from '@vertesia/common';
 import { Button, Popover, PopoverContent, PopoverTrigger, SelectList } from '@vertesia/ui/core';
 import { useUITranslation } from '@vertesia/ui/i18n';
 import clsx from 'clsx';
@@ -13,7 +13,7 @@ import { useObjectsActionContext } from './ObjectsActionHooks';
 import type { ObjectsActionSpec } from './ObjectsActionSpec';
 
 interface SelectionActionsProps {
-    type?: ContentObjectTypeItem;
+    type?: ContentObjectTypeCatalogEntry;
     allowMutations?: boolean;
     allowDelete?: boolean;
     /**

package/src/features/store/objects/upload/DocumentUploadModal.tsx

@@ -1,4 +1,4 @@
-import type { Collection, ContentObjectTypeItem, DynamicCollection } from '@vertesia/common';
+import type { Collection, ContentObjectTypeCatalogEntry, DynamicCollection } from '@vertesia/common';
 import {
     Button,
     errorMessage,
@@ -90,7 +90,7 @@ export function DocumentUploadModal({
     const [files, setFiles] = useState<File[]>([]);
     const [processedFiles, setProcessedFiles] = useState<FileWithMetadata[]>([]);
     const [processingDone, setProcessingDone] = useState(false);
-    const [selectedType, setSelectedType] = useState<ContentObjectTypeItem | null>(null);
+    const [selectedType, setSelectedType] = useState<ContentObjectTypeCatalogEntry | null>(null);
     const [fileStatuses, setFileStatuses] = useState<FileUploadStatus[]>([]);
     const [isUploading, setIsUploading] = useState(false);
     const [uploadComplete, setUploadComplete] = useState(false);

package/src/features/store/types/IntakePolicyEditor.tsx

@@ -1,4 +1,8 @@
-import { type ContentObjectType, type ContentTypeIntakePolicy, ContentTypeIntakePolicySchema } from '@vertesia/common';
+import {
+    type ContentObjectTypeCatalogEntry,
+    type ContentTypeIntakePolicy,
+    ContentTypeIntakePolicySchema,
+} from '@vertesia/common';
 import {
     Badge,
     Button,
@@ -25,7 +29,7 @@ import { IntakePolicyForm, type IntakePolicyFormSection } from './IntakePolicyFo
 
 interface IntakePolicyEditorProps {
     /** Content type whose intake policy is edited; omit when editing a standalone policy. */
-    objectType?: ContentObjectType;
+    objectType?: ContentObjectTypeCatalogEntry;
     /** Initial policy value when no objectType is given (e.g. the project default policy). */
     value?: ContentTypeIntakePolicy;
     /** Custom persistence (e.g. save to project configuration). Returns the saved policy.
@@ -644,13 +648,17 @@ function stringifyPolicy(policy: ContentTypeIntakePolicy | undefined) {
     return JSON.stringify(policy ?? EMPTY_POLICY, null, 2);
 }
 
-function createPolicyValidator() {
+function createPolicyValidator(): ValidateFunction<ContentTypeIntakePolicy> {
     const ajv = new Ajv({
         strict: false,
         allErrors: true,
     });
     addFormats(ajv);
-    return ajv.compile(ContentTypeIntakePolicySchema);
+    // The schema is plain JSON — generated from the canonical Zod schema, and deliberately typed as
+    // opaque data so the package root can export it without pulling Zod into the browser bundle. AJV
+    // therefore infers `unknown`; the type argument states what compiling THIS schema validates, and
+    // `store.contract.test.ts` is what keeps the claim true.
+    return ajv.compile<ContentTypeIntakePolicy>(ContentTypeIntakePolicySchema);
 }
 
 function parseAndValidatePolicy(

package/src/features/store/types/IntakePolicyForm.tsx

@@ -152,6 +152,13 @@ export function IntakePolicyForm({ policy, section, onChange, readonly = false }
                             onChange={(value) => setValue(['text_conversion', 'scope'], value)}
                             readonly={readonly}
                         />
+                        <NumberField
+                            label={t('intakePolicy.field.renderDpi')}
+                            value={policy.text_conversion?.render_dpi}
+                            min={72}
+                            onChange={(value) => setValue(['text_conversion', 'render_dpi'], value)}
+                            readonly={readonly}
+                        />
                     </div>
                     <TextAreaField
                         label={t('intakePolicy.field.instructions')}
@@ -161,6 +168,15 @@ export function IntakePolicyForm({ policy, section, onChange, readonly = false }
                     />
                 </FormSection>
 
+                <FormSection title={t('intakePolicy.section.conversionModel')}>
+                    <ModelConfigFields
+                        title={t('intakePolicy.field.model')}
+                        config={policy.text_conversion?.config}
+                        onChange={(value) => setValue(['text_conversion', 'config'], value)}
+                        readonly={readonly}
+                    />
+                </FormSection>
+
                 {policy.text_conversion?.method === 'custom' && (
                     <FormSection title={t('intakePolicy.section.customConversion')}>
                         <div className="grid gap-4 md:grid-cols-2">
@@ -243,6 +259,15 @@ export function IntakePolicyForm({ policy, section, onChange, readonly = false }
                     />
                 </FormSection>
 
+                <FormSection title={t('intakePolicy.section.extractionModel')}>
+                    <ModelConfigFields
+                        title={t('intakePolicy.field.model')}
+                        config={policy.extraction?.config}
+                        onChange={(value) => setValue(['extraction', 'config'], value)}
+                        readonly={readonly}
+                    />
+                </FormSection>
+
                 <FormSection title={t('intakePolicy.section.visionBudget')}>
                     <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-3">
                         <SelectField

package/src/features/store/types/ObjectSchemaEditor.tsx

@@ -1,4 +1,4 @@
-import type { ContentObjectType } from '@vertesia/common';
+import type { ContentObjectTypeCatalogEntry } from '@vertesia/common';
 import { Button, errorMessage, Panel, useTheme, useToast } from '@vertesia/ui/core';
 import { useUITranslation } from '@vertesia/ui/i18n';
 import { useUserSession } from '@vertesia/ui/session';
@@ -7,7 +7,7 @@ import { Ajv } from 'ajv';
 import { useMemo, useRef, useState } from 'react';
 
 interface ObjectSchemaEditorProps {
-    objectType: ContentObjectType;
+    objectType: ContentObjectTypeCatalogEntry;
     onSchemaUpdate: (jsonSchema: unknown) => void;
     readonly?: boolean;
 }