@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261004.085740Z

package/src/api-schemas/group.contract.test.ts

@@ -1,205 +0,0 @@
-import { Ajv2020 } from 'ajv/dist/2020.js';
-import { describe, expect, it } from 'vitest';
-import type { CreateUserGroupPayload, UpdateUserGroupPayload, UserGroup } from '../group.js';
-import type { User, UserRef } from '../user.js';
-import type { JsonObject } from './adapter.js';
-import type { UserGroupArrayFromSchema } from './group.js';
-import { ApiSchemaComponents, apiComponentRef, validateApiRequest, validateApiResponse } from './registry.js';
-import type { UserRefArrayFromSchema } from './user.js';
-
-/** Exact type identity — `extends` in both directions is too weak (any/unknown slip through). */
-type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-function assertType<T extends true>(_ok: T): void {}
-
-function compile(name: string, components: Readonly<Record<string, JsonObject>> = ApiSchemaComponents) {
-    const ajv = new Ajv2020({ strictSchema: false, allErrors: true });
-    ajv.addSchema({ $id: 'vertesia://openapi', components: { schemas: components } });
-    return ajv.compile({ $ref: `vertesia://openapi${apiComponentRef(name as never)}` });
-}
-
-const VALID_GROUP = {
-    id: 'g1',
-    account: 'a1',
-    name: 'Engineering',
-    tags: ['eng'],
-    created_at: '2026-07-30T10:00:00.000Z',
-    updated_at: '2026-07-30T10:00:00.000Z',
-};
-
-const VALID_REF = { id: 'u1', name: 'Someone', email: 'someone@acme.com' };
-
-describe('gate 1 — the schema is the single source of truth for the public group types', () => {
-    it('publishes the exact schema-derived type, not a hand-written twin', () => {
-        assertType<Equals<UserGroupArrayFromSchema, UserGroup[]>>(true);
-        assertType<Equals<UserRefArrayFromSchema, UserRef[]>>(true);
-        expect(true).toBe(true);
-    });
-
-    it('types the timestamps as the strings a client actually receives', () => {
-        // They were `Date` on the public type while the document published `format: date-time`
-        // strings. JSON has no date type, so the old declaration described the Mongoose document
-        // rather than the response — this is the correction, and the reason it is a compile-time
-        // break for anyone who was calling `.getTime()` on one.
-        assertType<Equals<UserGroup['created_at'], string>>(true);
-        assertType<Equals<UserGroup['updated_at'], string>>(true);
-        assertType<Equals<UserGroup['tags'], string[]>>(true);
-        assertType<Equals<UserGroup['allowed_projects'], string[] | undefined>>(true);
-        expect(true).toBe(true);
-    });
-
-    it('derives UserRef from User rather than restating four fields', () => {
-        // `.pick()` on UserSchema, so a change to how `User` declares one of these follows through
-        // instead of leaving a twin behind. The requiredness comes with it: `email` is required on
-        // both, which is why the members listing has to map rather than serialize.
-        assertType<Equals<UserRef['id'], User['id']>>(true);
-        assertType<Equals<UserRef['name'], User['name']>>(true);
-        assertType<Equals<UserRef['email'], User['email']>>(true);
-        assertType<Equals<UserRef['picture'], User['picture']>>(true);
-        // And nothing else came across.
-        assertType<Equals<keyof UserRef, 'id' | 'name' | 'email' | 'picture'>>(true);
-        expect(true).toBe(true);
-    });
-
-    it('derives both payloads from the group rather than restating its fields', () => {
-        // Same reasoning as UserRef, applied to the write side: each payload is a subset of the
-        // group, so the field types follow the response. Only requiredness differs, and only where
-        // it should — `tags` is required on a group the server always populates and optional in a
-        // payload the caller need not send.
-        assertType<Equals<CreateUserGroupPayload['name'], UserGroup['name']>>(true);
-        assertType<Equals<CreateUserGroupPayload['description'], UserGroup['description']>>(true);
-        assertType<Equals<CreateUserGroupPayload['tags'], string[] | undefined>>(true);
-        assertType<Equals<keyof CreateUserGroupPayload, 'name' | 'description' | 'tags' | 'allowed_projects'>>(true);
-        assertType<Equals<UpdateUserGroupPayload['properties'], UserGroup['properties']>>(true);
-        assertType<Equals<UpdateUserGroupPayload['clearance'], UserGroup['clearance']>>(true);
-        assertType<Equals<UpdateUserGroupPayload['compartments'], UserGroup['compartments']>>(true);
-        // The whitelist is what the pick leaves out: nothing server-owned is writable.
-        assertType<
-            Equals<
-                keyof UpdateUserGroupPayload,
-                'name' | 'description' | 'tags' | 'properties' | 'clearance' | 'compartments' | 'allowed_projects'
-            >
-        >(true);
-        expect(true).toBe(true);
-    });
-});
-
-describe('gate 2 — the published components match the closure the types come from', () => {
-    it('does not declare members on the group component', () => {
-        // Three handlers were shipping `members` — two by populating a `select: false` path, one by
-        // returning the in-memory document — while the component is closed and has never declared
-        // it. Members are published by their own route as UserRef[].
-        expect(Object.keys(ApiSchemaComponents.UserGroup.properties as JsonObject)).not.toContain('members');
-        expect(ApiSchemaComponents.UserGroup.additionalProperties).toBe(false);
-    });
-
-    it('publishes UserRef as its own component, not a $ref back to User', () => {
-        // `.pick()` drops the `id: 'User'` metadata, which is what keeps the projection a separate
-        // component. If it carried the id across, every UserRef slot would suddenly promise a whole
-        // User to generated clients.
-        expect(JSON.stringify(ApiSchemaComponents.UserRef)).not.toContain('$ref');
-        expect(ApiSchemaComponents.UserRef.required).toEqual(['id', 'name', 'email']);
-        expect(ApiSchemaComponents.UserRefArray).toEqual({
-            type: 'array',
-            items: { $ref: '#/components/schemas/UserRef' },
-        });
-    });
-
-    it('keeps the timestamps enforceable rather than merely documented', () => {
-        const props = ApiSchemaComponents.UserGroup.properties as Record<string, JsonObject>;
-        expect(props.created_at).toEqual({ type: 'string', format: 'date-time' });
-        expect(ApiSchemaComponents.UserGroup.required).toEqual([
-            'id',
-            'account',
-            'name',
-            'tags',
-            'created_at',
-            'updated_at',
-        ]);
-    });
-});
-
-describe('gate 3 — AJV validates the same canonical objects that are published', () => {
-    it('accepts a minimal group and rejects a missing required field', () => {
-        const validate = compile('UserGroup');
-        expect(validate(VALID_GROUP)).toBe(true);
-        const { tags: _dropped, ...incomplete } = VALID_GROUP;
-        expect(validate(incomplete)).toBe(false);
-    });
-
-    it('rejects the internal fields a serialized document would have leaked', () => {
-        const validate = compile('UserGroup');
-        expect(validate({ ...VALID_GROUP, members: ['u1'] })).toBe(false);
-        expect(validate({ ...VALID_GROUP, _id: 'deadbeef' })).toBe(false);
-        expect(validate({ ...VALID_GROUP, __v: 0 })).toBe(false);
-    });
-
-    it('requires a name on the update payload, which both handlers checked by hand', () => {
-        const validate = compile('UpdateUserGroupPayload');
-        expect(validate({ name: 'Renamed' })).toBe(true);
-        expect(validate({})).toBe(false);
-        expect(validate({ name: 'Renamed', rogue_field: 1 })).toBe(false);
-    });
-
-    it('accepts a create payload with only a name', () => {
-        const validate = compile('CreateUserGroupPayload');
-        expect(validate({ name: 'Engineering' })).toBe(true);
-        expect(validate({ name: 'Engineering', allowed_projects: [] })).toBe(true);
-        // `properties` and `clearance` are updatable but not settable at creation, and never were.
-        expect(validate({ name: 'Engineering', clearance: 3 })).toBe(false);
-    });
-
-    it('documents allowed_projects for the request rather than inheriting the response text', () => {
-        // The one field where picking is not enough: the response explains what an empty list MEANS,
-        // the request explains what sending one DOES. Overriding the picked field is how a payload
-        // keeps request-specific documentation — and the same mechanism a field with genuinely
-        // different request semantics would need.
-        const create = (ApiSchemaComponents.CreateUserGroupPayload.properties as Record<string, JsonObject>)
-            .allowed_projects;
-        const group = (ApiSchemaComponents.UserGroup.properties as Record<string, JsonObject>).allowed_projects;
-        expect(create.description).toBe('Restrict the new group to the given projects (empty/absent = org-wide).');
-        expect(create.description).not.toBe(group.description);
-        // Everything except the description still comes from the group.
-        expect({ ...create, description: undefined }).toEqual({ ...group, description: undefined });
-    });
-});
-
-describe('gate 4 — runtime enforcement uses the published components', () => {
-    it('enforces the date-time format the timestamps claim', () => {
-        // Through the registry rather than the local `compile` helper: the production validator
-        // registers ajv-formats, and a bare Ajv2020 ignores `format` entirely.
-        expect(validateApiResponse('UserGroup', { ...VALID_GROUP, created_at: 'yesterday' }).valid).toBe(false);
-        expect(validateApiResponse('UserGroup', VALID_GROUP).valid).toBe(true);
-    });
-
-    it('rejects an undeclared update field without removing it', () => {
-        const payload: Record<string, unknown> = { name: 'Acme', rogue_field: 42 };
-        const result = validateApiRequest('UpdateUserGroupPayload', payload);
-        expect(result.valid).toBe(false);
-        expect(payload.rogue_field).toBe(42);
-    });
-
-    it('checks every member of the group listing against the same UserGroup component', () => {
-        expect(validateApiResponse('UserGroupArray', [VALID_GROUP, VALID_GROUP]).valid).toBe(true);
-        expect(validateApiResponse('UserGroupArray', []).valid).toBe(true);
-        // One group still carrying its members is what the unmapped listing would have produced.
-        expect(validateApiResponse('UserGroupArray', [VALID_GROUP, { ...VALID_GROUP, members: [] }]).valid).toBe(false);
-    });
-
-    it('checks every member of the members listing against UserRef', () => {
-        expect(validateApiResponse('UserRefArray', [VALID_REF]).valid).toBe(true);
-        // A user Mongo holds with no email — required on the wire, which is why the handler maps.
-        const { email: _dropped, ...withoutEmail } = VALID_REF;
-        expect(validateApiResponse('UserRefArray', [withoutEmail]).valid).toBe(false);
-        expect(validateApiResponse('UserRefArray', [{ ...VALID_REF, email: '' }]).valid).toBe(true);
-        // And the whole user document, which is what serializing the populated doc would send.
-        expect(validateApiResponse('UserRefArray', [{ ...VALID_REF, clearance: 3 }]).valid).toBe(false);
-    });
-
-    it('hands back the component type on the valid branch', () => {
-        const result = validateApiResponse('UserGroup', VALID_GROUP);
-        expect(result.valid).toBe(true);
-        if (result.valid) {
-            assertType<Equals<typeof result.data, UserGroup>>(true);
-        }
-    });
-});

package/src/api-schemas/indexing.contract.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { GenericCommandResponse } from '../common.js';
-import type { RecalculateEmbeddingsQuery } from '../embeddings.js';
-import type {
-    DriftAnalysisStatusResponse,
-    EmbeddingsStatusResponse,
-    IndexingStatusResponse,
-    ProjectConfigurationEmbeddingEnablePayload,
-    ReindexAgentRunsPayload,
-    ReindexAgentRunsResponse,
-    StartProjectReindexPayload,
-} from '../project.js';
-import { WorkflowExecutionStatus } from '../store/workflow.js';
-import type { GenericCommandResponseSchema } from './commands.js';
-import type {
-    EmbeddingsStatusResponseSchema,
-    ProjectConfigurationEmbeddingEnablePayloadSchema,
-    RecalculateEmbeddingsQuerySchema,
-} from './embeddings.js';
-import type {
-    DriftAnalysisStatusResponseSchema,
-    IndexingStatusResponseSchema,
-    ReindexAgentRunsPayloadSchema,
-    ReindexAgentRunsResponseSchema,
-    StartProjectReindexPayloadSchema,
-} from './indexing.js';
-import { validateApiRequest, validateApiResponse } from './registry.js';
-
-type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-function assertType<T extends true>(_value: T): void {}
-
-describe('indexing and embedding API contracts', () => {
-    it('derives every public type from its domain schema', () => {
-        assertType<Equals<GenericCommandResponse, typeof GenericCommandResponseSchema._output>>(true);
-        assertType<Equals<EmbeddingsStatusResponse, typeof EmbeddingsStatusResponseSchema._output>>(true);
-        assertType<Equals<RecalculateEmbeddingsQuery, typeof RecalculateEmbeddingsQuerySchema._output>>(true);
-        assertType<Equals<IndexingStatusResponse, typeof IndexingStatusResponseSchema._output>>(true);
-        assertType<Equals<DriftAnalysisStatusResponse, typeof DriftAnalysisStatusResponseSchema._output>>(true);
-        assertType<
-            Equals<
-                ProjectConfigurationEmbeddingEnablePayload,
-                typeof ProjectConfigurationEmbeddingEnablePayloadSchema._output
-            >
-        >(true);
-        assertType<Equals<StartProjectReindexPayload, typeof StartProjectReindexPayloadSchema._output>>(true);
-        assertType<Equals<ReindexAgentRunsPayload, typeof ReindexAgentRunsPayloadSchema._output>>(true);
-        assertType<Equals<ReindexAgentRunsResponse, typeof ReindexAgentRunsResponseSchema._output>>(true);
-    });
-
-    it('rejects undeclared request fields while allowing both optional reindex bodies', () => {
-        expect(validateApiRequest('StartProjectReindexPayload', undefined).valid).toBe(false);
-        expect(validateApiRequest('StartProjectReindexPayload', {}).valid).toBe(true);
-        expect(validateApiRequest('StartProjectReindexPayload', { unexpected: true }).valid).toBe(false);
-        expect(validateApiRequest('ReindexAgentRunsPayload', {}).valid).toBe(true);
-        expect(validateApiRequest('ReindexAgentRunsPayload', { recreate_index: true, unexpected: true }).valid).toBe(
-            false,
-        );
-    });
-
-    it('allows only the explicit synchronous embedding recalculation override', () => {
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', {}).valid).toBe(true);
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', { mode: 'sync' }).valid).toBe(true);
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', { force: true }).valid).toBe(true);
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', { mode: 'sync', force: true }).valid).toBe(true);
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', { force_renditions: true }).valid).toBe(false);
-        expect(validateApiRequest('RecalculateEmbeddingsQuery', { mode: 'batch' }).valid).toBe(false);
-    });
-
-    it('validates the optional batch summary without exposing stored run fields', () => {
-        const summary = {
-            id: 'run-1',
-            state: 'completed_with_errors',
-            model: 'model-1',
-            created_at: '2026-01-01T00:00:00Z',
-            applied: 110,
-            skipped: 17,
-            failed: 0,
-            stale: 0,
-        };
-        expect(
-            validateApiResponse('EmbeddingsStatusResponse', {
-                status: 'success',
-                vectorIndex: { status: 'READY' },
-                latestBatchRun: summary,
-            }).valid,
-        ).toBe(true);
-        expect(validateApiResponse('EmbeddingBatchRunSummary', { ...summary, applied: -1 }).valid).toBe(false);
-        expect(validateApiResponse('EmbeddingBatchRunSummary', { ...summary, prefix_uri: 'private' }).valid).toBe(
-            false,
-        );
-    });
-
-    it('keeps drift workflow status numeric and nullable identifiers explicit', () => {
-        expect(
-            validateApiResponse('DriftAnalysisStatusResponse', {
-                workflow_id: null,
-                workflow_run_id: null,
-                status: WorkflowExecutionStatus.UNKNOWN,
-            }).valid,
-        ).toBe(true);
-        expect(
-            validateApiResponse('DriftAnalysisStatusResponse', {
-                workflow_id: null,
-                workflow_run_id: null,
-                status: 'NOT_FOUND',
-            }).valid,
-        ).toBe(false);
-    });
-
-    it('validates command and embedding responses against the published components', () => {
-        expect(validateApiResponse('GenericCommandResponse', { status: 'ok', message: 'done' }).valid).toBe(true);
-        expect(
-            validateApiResponse('GenericCommandResponse', { status: 'ok', message: 'done', extra: true }).valid,
-        ).toBe(false);
-        expect(
-            validateApiResponse('EmbeddingsStatusResponse', {
-                status: 'success',
-                vectorIndex: { status: 'READY' },
-            }).valid,
-        ).toBe(true);
-    });
-});

package/src/api-schemas/interaction.contract.test.ts

@@ -1,307 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { AsyncConversationExecutionPayload } from '../interaction.js';
-import {
-    AsyncConversationExecutionPayloadSchema,
-    ComputeRunFacetPayloadSchema,
-    ComputeRunFacetsResponseSchema,
-    ConversationStateSchema,
-    ExecutionRunRefSchema,
-    FindRunResultSchema,
-    InCodeInteractionSchema,
-    InteractionCreatePayloadSchema,
-    InteractionPromptSegmentInputSchema,
-    InteractionSchema,
-    InteractionUpdatePayloadSchema,
-    PromptSegmentDefSchema,
-    ResolvedCatalogInteractionSchema,
-    RunClonePayloadSchema,
-} from './interaction.js';
-import { validateApiRequest } from './registry.js';
-
-describe('conversation state contract', () => {
-    it('publishes the tool catalog storage scope used to resolve tool references', () => {
-        expect(ConversationStateSchema.shape.tool_catalog_storage_id.safeParse('process-run-1').success).toBe(true);
-    });
-});
-
-describe('in-code interaction contract', () => {
-    it('retains prompt schemas when resolving a catalog interaction', () => {
-        const interaction = InCodeInteractionSchema.parse({
-            type: 'sys',
-            id: 'sys:GeneralAgent',
-            name: 'GeneralAgent',
-            title: 'General Agent',
-            tags: ['agent'],
-            agent_runner_options: { is_agent: true, request_template: '{{user_prompt}}' },
-            prompts: [
-                {
-                    role: 'user',
-                    content: '{{user_prompt}}',
-                    content_type: 'handlebars',
-                    schema: {
-                        type: 'object',
-                        properties: { user_prompt: { type: 'string', editor: 'textarea' } },
-                    },
-                },
-            ],
-        });
-
-        expect(interaction.prompts[0]?.schema).toMatchObject({
-            properties: { user_prompt: { type: 'string' } },
-        });
-    });
-
-    it('requires normalized title and tags only on the resolved response', () => {
-        const authoringShape = {
-            type: 'sys',
-            id: 'sys:Untitled',
-            name: 'Untitled',
-            prompts: [],
-        };
-
-        expect(InCodeInteractionSchema.safeParse(authoringShape).success).toBe(true);
-        expect(ResolvedCatalogInteractionSchema.safeParse(authoringShape).success).toBe(false);
-        expect(
-            ResolvedCatalogInteractionSchema.safeParse({ ...authoringShape, title: 'Untitled', tags: [] }).success,
-        ).toBe(true);
-    });
-});
-
-describe('AsyncConversationExecutionPayload contract', () => {
-    it('accepts caller-provided metadata and enrichment controls', () => {
-        const payload: AsyncConversationExecutionPayload = {
-            type: 'conversation',
-            interaction: 'sys:AppTester',
-            title: 'Manual title',
-            topic: 'Manual topic',
-            generate_topic: false,
-            generate_lessons: false,
-        };
-
-        expect(AsyncConversationExecutionPayloadSchema.parse(payload)).toMatchObject(payload);
-    });
-
-    it('retains an immutable app-version execution target', () => {
-        const payload: AsyncConversationExecutionPayload = {
-            type: 'conversation',
-            interaction: 'sys:AppTester',
-            app_version: '20260804T022611971Z',
-        };
-
-        expect(AsyncConversationExecutionPayloadSchema.parse(payload)).toMatchObject({
-            app_version: '20260804T022611971Z',
-        });
-    });
-
-    it('accepts Process-authored agent execution policy', () => {
-        const payload: AsyncConversationExecutionPayload = {
-            type: 'conversation',
-            interaction: 'sys:AppDeveloper',
-            agent_policy: {
-                phases: [
-                    {
-                        id: 'saved',
-                        tools: ['app_workspace_save'],
-                        tool_input_contains: [{ field: 'mode', contains: 'commit' }],
-                        recovery_prompt: 'Save before finishing.',
-                    },
-                ],
-                phase_resets: [{ tools: ['app_workspace_edit'], to_phase: 'saved' }],
-                action_phase_count: 1,
-                action_phase_max_tokens: 4_096,
-                completion_prompt: 'Return the structured result now.',
-            },
-        };
-
-        expect(AsyncConversationExecutionPayloadSchema.parse(payload)).toMatchObject(payload);
-    });
-
-    it('rejects a non-string app-version target', () => {
-        expect(() =>
-            AsyncConversationExecutionPayloadSchema.parse({
-                type: 'conversation',
-                interaction: 'sys:AppTester',
-                app_version: 42,
-            }),
-        ).toThrow();
-    });
-});
-
-describe('run facet contracts', () => {
-    const facets = [
-        { name: 'environments', field: 'environment' },
-        { name: 'interactions', field: 'interaction' },
-        { name: 'models', field: 'modelId' },
-        { name: 'statuses', field: 'status' },
-        { name: 'finish_reason', field: 'finish_reason' },
-    ];
-
-    it('accepts exactly the supported run facet pairs', () => {
-        expect(ComputeRunFacetPayloadSchema.parse({ facets })).toEqual({ facets });
-    });
-
-    it.each(['tags', 'created_by', 'start', 'end'])('rejects the removed %s facet', (field) => {
-        expect(ComputeRunFacetPayloadSchema.safeParse({ facets: [{ name: field, field }] }).success).toBe(false);
-    });
-
-    it('rejects mismatched and additional facet names', () => {
-        expect(ComputeRunFacetPayloadSchema.safeParse({ facets: [{ name: 'models', field: 'status' }] }).success).toBe(
-            false,
-        );
-        expect(ComputeRunFacetPayloadSchema.safeParse({ facets: [{ name: 'custom', field: 'modelId' }] }).success).toBe(
-            false,
-        );
-    });
-
-    it('keeps removed facet fields available as query filters', () => {
-        const query = {
-            tags: ['visible'],
-            created_by: 'user:123',
-            start: '2026-08-01T00:00:00.000Z',
-            end: '2026-08-02T00:00:00.000Z',
-        };
-
-        expect(ComputeRunFacetPayloadSchema.parse({ facets: [], query })).toEqual({ facets: [], query });
-    });
-
-    it('rejects removed and custom response facets', () => {
-        expect(ComputeRunFacetsResponseSchema.safeParse({ tags: [] }).success).toBe(false);
-        expect(ComputeRunFacetsResponseSchema.safeParse({ custom: [] }).success).toBe(false);
-    });
-});
-
-describe('run response contracts', () => {
-    it('retains an environment ID when a run references a deleted environment', () => {
-        expect(ExecutionRunRefSchema.shape.environment.parse('env-deleted')).toBe('env-deleted');
-        expect(ExecutionRunRefSchema.shape.environment.parse(null)).toBeNull();
-    });
-
-    it('models the arbitrary stored-field projection returned by /runs/find', () => {
-        expect(
-            FindRunResultSchema.parse({
-                id: 'run-1',
-                environment: 'env-1',
-                account: 'account-1',
-                project: 'project-1',
-                interaction: 'interaction-1',
-                result: [],
-                parameters: { query: 'test' },
-            }),
-        ).toMatchObject({ environment: 'env-1', account: 'account-1', project: 'project-1' });
-    });
-
-    it('does not publish run persistence-only fields', () => {
-        expect(() => FindRunResultSchema.parse({ interaction_code: 'sys:Example' })).toThrow();
-        expect(() => FindRunResultSchema.parse({ tmp_prompt: [] })).toThrow();
-    });
-
-    it('models enriched supported run facet buckets', () => {
-        expect(
-            ComputeRunFacetsResponseSchema.parse({
-                environments: [{ _id: 'env-1', count: 2, name: 'Default' }],
-                interactions: [{ _id: 'interaction-1', count: 1, name: 'Example', status: 'published', version: 3 }],
-                models: [{ _id: 'gpt', count: 2 }],
-                total: 2,
-            }),
-        ).toMatchObject({ total: 2 });
-    });
-});
-
-describe('interaction contracts', () => {
-    const populatedPrompt = {
-        role: 'user',
-        content: 'Hello',
-        content_type: 'text',
-        id: 'prompt-1',
-        name: 'Greeting',
-        status: 'draft',
-        version: 1,
-        project: 'project-1',
-        created_by: 'user-1',
-        updated_by: 'user-1',
-        created_at: '2026-08-20T00:00:00.000Z',
-        updated_at: '2026-08-20T00:00:00.000Z',
-    };
-
-    it('accepts the media-result storage setting on interaction payloads and responses', () => {
-        expect(InteractionSchema.shape.store_media_results.parse(true)).toBe(true);
-        expect(InteractionCreatePayloadSchema.shape.store_media_results.parse(false)).toBe(false);
-        expect(InteractionUpdatePayloadSchema.shape.store_media_results.parse(true)).toBe(true);
-    });
-
-    it('keeps legacy populated prompts valid in interaction write payloads', () => {
-        const segment = { type: 'template', template: populatedPrompt };
-
-        expect(InteractionPromptSegmentInputSchema.safeParse(segment).success).toBe(true);
-        expect(
-            InteractionPromptSegmentInputSchema.safeParse({
-                ...segment,
-                template: { ...populatedPrompt, edit_revision: 3 },
-            }).success,
-        ).toBe(true);
-    });
-
-    it('still requires edit revisions on populated prompts returned by the API', () => {
-        const segment = { type: 'template', template: populatedPrompt };
-
-        expect(PromptSegmentDefSchema.safeParse(segment).success).toBe(false);
-        expect(
-            PromptSegmentDefSchema.safeParse({
-                ...segment,
-                template: { ...populatedPrompt, edit_revision: 3 },
-            }).success,
-        ).toBe(true);
-    });
-});
-
-describe('user message payload contract', () => {
-    const base = {
-        run: { id: 'run-1', account: 'acc-1', project: 'proj-1' },
-        environment: 'env-1',
-        options: { model: 'model-1' },
-        tools: [],
-        message: 'Search the other collection instead.',
-    };
-
-    it('accepts tool results owed to the model alongside the message', () => {
-        // A stop or an approval denial can leave results undelivered. They have to travel with
-        // the message that resumes the conversation: the payload is strict, so before `results`
-        // existed here the server rejected them and the work was silently dropped.
-        const result = validateApiRequest('UserMessagePayload', {
-            ...base,
-            results: [{ tool_use_id: 'search-1', content: 'found 3 docs', is_error: false }],
-        });
-
-        expect(result.valid).toBe(true);
-    });
-
-    it('still accepts a message with no owed results', () => {
-        expect(validateApiRequest('UserMessagePayload', base).valid).toBe(true);
-    });
-
-    it('stays closed to undeclared fields', () => {
-        expect(validateApiRequest('UserMessagePayload', { ...base, unsupported: true }).valid).toBe(false);
-    });
-});
-
-describe('inference workflow attribution', () => {
-    it('keeps required clone workflow identifiers free of execution deprecation metadata', () => {
-        const workflow = RunClonePayloadSchema.shape.workflow.shape;
-        expect(workflow.run_id.meta()?.deprecated).toBeUndefined();
-        expect(workflow.workflow_id.meta()?.deprecated).toBeUndefined();
-    });
-    it('accepts root agent attribution on execution and clone requests', () => {
-        const workflow = { run_id: 'child-run', workflow_id: 'workstream:parent:child', agent_run_id: 'root-agent' };
-        expect(validateApiRequest('ExecutionRunWorkflow', workflow).valid).toBe(true);
-        expect(validateApiRequest('RunClonePayload', { source_run_id: 'source', workflow }).valid).toBe(true);
-        expect(
-            validateApiRequest('ExecutionRunWorkflow', { run_id: 'legacy', workflow_id: 'AgentRun:legacy' }).valid,
-        ).toBe(true);
-    });
-});
-
-describe('background inference telemetry contract', () => {
-    it('accepts the background call type in the generated runtime contract', () => {
-        expect(validateApiRequest('LlmCallType', 'background').valid).toBe(true);
-    });
-});