@vertesia/common 1.5.0-dev.20260807.073259Z → 1.5.0-dev.20260901.005903Z

package/src/api-schemas/workflow-runs.ts

@@ -1,6 +1,6 @@
 // Runtime schemas for the workflow runs API domain.
 
-import { JSONObjectSchema, JSONSchemaSchema, JSONValueSchema, ModelOptionsSchema } from '@llumiverse/common/schemas';
+import { JSONObjectSchema, JSONSchemaSchema, JSONValueSchema } from '@llumiverse/common/schemas';
 import { z } from 'zod';
 import type { ActivityTypeDefinition } from '../store/activity-catalog.js';
 import { CompactMessageSchema } from './agent-runs.js';
@@ -13,6 +13,7 @@ import {
     UserChannelSchema,
 } from './interaction.js';
 import { nullableStringSchema } from './schema-primitives.js';
+import { InteractionExecutionConfigurationSchema } from './store.js';
 
 export const RestartAgentRunPayloadSchema = z
     .strictObject({
@@ -63,6 +64,8 @@ export const ActivityTypeDefinitionSchema: z.ZodType<ActivityTypeDefinition> = z
             innerType: ActivityTypeDefinitionSchema.optional(),
             enum: z.union([z.array(z.string()), z.array(z.number())]).optional(),
             union: z.array(ActivityTypeDefinitionSchema).optional(),
+            keyType: ActivityTypeDefinitionSchema.optional(),
+            valueType: ActivityTypeDefinitionSchema.optional(),
         }),
     )
     .meta({ id: 'ActivityTypeDefinition' });
@@ -104,16 +107,13 @@ export const WorkflowInteractionVarsSchema = z
         user_channels: z.array(UserChannelSchema).optional(),
         data: JSONObjectSchema.optional(),
         tool_names: z.array(z.string()),
-        config: z.strictObject({
-            environment: z.string(),
-            model: z.string(),
-            model_options: ModelOptionsSchema.optional(),
-        }),
+        config: InteractionExecutionConfigurationSchema,
         interactionParamsSchema: JSONSchemaSchema.optional(),
         collection_id: z.string().optional(),
         disabled_mcp_collections: z.array(z.string()).optional(),
         checkpoint_tokens: z.number().optional(),
         version: z.number().optional(),
+        agent_run_id: z.string().optional(),
     })
     .meta({ id: 'WorkflowInteractionVars' });
 
@@ -211,6 +211,7 @@ export const WorkflowRunSchema = z
             .boolean()
             .meta({ description: 'Whether this conversation is interactive (accepts user input).' })
             .optional(),
+        memo: z.looseObject({}).nullable().optional(),
     })
     .meta({ id: 'WorkflowRun' });
 
@@ -620,8 +621,9 @@ export const WorkflowRunWithDetailsSchema = z
             .meta({ description: 'Whether this conversation is interactive (accepts user input).' })
             .optional(),
         history: WorkflowHistorySchema.optional(),
-        memo: z.union([z.object({}).catchall(z.unknown()), z.null()]).optional(),
+        memo: z.looseObject({}).nullable().optional(),
         pendingActivities: z.array(PendingActivitySchema).optional(),
+        children: z.array(WorkflowRunSchema).optional(),
     })
     .meta({ id: 'WorkflowRunWithDetails' });
 

package/src/api-schemas/zeno-response-contracts.test.ts

@@ -0,0 +1,344 @@
+import { describe, expect, it } from 'vitest';
+import { validateApiRequest, validateApiResponse } from './registry.js';
+
+const timestamp = '2026-08-05T12:00:00.000Z';
+
+const contentObject = {
+    id: '64b000000000000000000001',
+    name: 'Quarterly report',
+    updated_by: 'user:legacy',
+    created_by: 'user:legacy',
+    created_at: timestamp,
+    updated_at: timestamp,
+    location: '/Quarterly report',
+    status: 'ready',
+    properties: {},
+    revision: { root: '64b000000000000000000001', head: true },
+    sensitivity: 2,
+    compartments: ['finance'],
+};
+
+const autonomousRun = {
+    id: '64b000000000000000000002',
+    account: '64b000000000000000000003',
+    project: '64b000000000000000000004',
+    run_kind: 'agent',
+    run_type: 'autonomous',
+    status: 'running',
+    started_by: 'user:legacy',
+    started_at: timestamp,
+    created_at: timestamp,
+    updated_at: timestamp,
+    interaction: 'sys:generic_question',
+    interactionRef: {
+        id: 'sys:generic_question',
+        name: 'Generic question',
+        endpoint: 'sys:generic_question',
+        status: 'code',
+        version: 0,
+        tags: [],
+        updated_at: timestamp,
+    },
+    environmentRef: {
+        id: '64b000000000000000000005',
+        name: 'Default',
+        type: 'environment',
+    },
+    config: {
+        environment: '64b000000000000000000005',
+        model: 'legacy-provider/model',
+    },
+    interactive: true,
+};
+
+const processRun = {
+    id: '64b000000000000000000009',
+    account: '64b000000000000000000003',
+    project: '64b000000000000000000004',
+    run_kind: 'process',
+    run_type: 'programmatic',
+    status: 'running',
+    started_by: 'user:legacy',
+    started_at: timestamp,
+    created_at: timestamp,
+    updated_at: timestamp,
+    process_definition_snapshot: {
+        format_version: 1,
+        process: 'Process',
+        initial: 'start',
+        context: { schema: {}, initial: {} },
+        nodes: { start: { type: 'final' } },
+    },
+    process_state: {
+        context: {},
+        current_node: 'start',
+        node_history: [],
+        node_history_ref: { path: 'history', latest_sequence: 0, count: 0 },
+        sequence: 0,
+    },
+};
+
+describe('Zeno read-side response contracts', () => {
+    it('accepts conversation metadata and enrichment controls when creating an agent run', () => {
+        expect(
+            validateApiRequest('CreateAgentRunPayload', {
+                interaction: 'sys:generic_question',
+                title: 'Manual title',
+                topic: 'Manual topic',
+                generate_topic: false,
+                generate_lessons: false,
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiRequest('RecordAgentRunPayload', {
+                interaction: 'sys:generic_question',
+                workflow_id: 'workflow-1',
+                first_workflow_run_id: 'run-1',
+                title: 'Manual title',
+                topic: 'Manual topic',
+                generate_topic: false,
+                generate_lessons: false,
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('keeps the corresponding write contracts strict', () => {
+        expect(
+            validateApiRequest('CreateAgentRunPayload', {
+                interaction: 'sys:generic_question',
+                config: {
+                    environment: '64b000000000000000000005',
+                    model: 'legacy-provider/model',
+                    model_options: { provider_extension: true },
+                },
+            }).valid,
+        ).toBe(false);
+        expect(
+            validateApiRequest('CreateProcessDefinitionPayload', {
+                name: 'Legacy process',
+                definition: { process: 'Legacy', initial: 'start', context: {}, nodes: {} },
+            }).valid,
+        ).toBe(false);
+    });
+
+    it('accepts runtime model and effort status updates', () => {
+        expect(
+            validateApiRequest('UpdateAgentRunStatusPayload', {
+                model: 'gpt-5.6-sol',
+                effort: 'xhigh',
+            }).valid,
+        ).toBe(true);
+        expect(validateApiRequest('UpdateAgentRunStatusPayload', { effort: null }).valid).toBe(true);
+        expect(validateApiRequest('UpdateAgentRunStatusPayload', { effort: 'unbounded' }).valid).toBe(false);
+    });
+
+    it('accepts normalized autonomous runs and projected refs', () => {
+        expect(validateApiResponse('AgentRun', autonomousRun).valid).toBe(true);
+        expect(validateApiResponse('AgentRunResponse', autonomousRun).valid).toBe(true);
+        expect(validateApiResponse('AgentRunResponse', processRun).valid).toBe(true);
+        expect(
+            validateApiResponse('ListAgentRunsResponse', {
+                items: [autonomousRun],
+                total_count: 1,
+                next_cursor: null,
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('uses the current compact message contract for update responses', () => {
+        const response = { messages: [{ t: 2, d: { files: ['legacy-file-id'] } }] };
+        expect(validateApiResponse('AgentRunUpdatesResponse', response).valid).toBe(true);
+        expect(validateApiResponse('WorkflowRunUpdatesResponse', response).valid).toBe(true);
+    });
+
+    it('accepts normalized legacy collections and full or projected content objects', () => {
+        expect(
+            validateApiResponse('CollectionArray', [
+                {
+                    id: '64b000000000000000000006',
+                    name: 'Legacy',
+                    created_by: '',
+                    updated_by: '',
+                    created_at: timestamp,
+                    updated_at: timestamp,
+                    dynamic: false,
+                    status: 'active',
+                    skip_head_sync: false,
+                    parents: ['64b000000000000000000007'],
+                },
+            ]).valid,
+        ).toBe(true);
+        expect(validateApiResponse('ContentObjectApiResponse', contentObject).valid).toBe(true);
+        expect(validateApiResponse('ContentObjectApiResponseArray', [contentObject]).valid).toBe(true);
+        const { sensitivity: _sensitivity, compartments: _compartments, ...contentObjectItem } = contentObject;
+        expect(validateApiResponse('ContentObjectItemApiResponseArray', [contentObjectItem]).valid).toBe(true);
+        expect(validateApiResponse('ProjectedContentObjectApiResponse', { id: contentObject.id, score: 1 }).valid).toBe(
+            true,
+        );
+        expect(validateApiResponse('ProjectedContentObjectApiResponse', { id: contentObject.id, bogus: 1 }).valid).toBe(
+            false,
+        );
+        expect(
+            validateApiResponse('ObjectSearchResponse', {
+                results: [{ id: contentObject.id, score: 1 }],
+                facets: { total: 1 },
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('accepts display metadata on child-workflow steps', () => {
+        expect(
+            validateApiResponse('DSLWorkflowDefinitionResponse', {
+                id: 'workflow-1',
+                name: 'Parent workflow',
+                edit_revision: 1,
+                created_by: 'user-1',
+                updated_by: 'user-1',
+                created_at: timestamp,
+                updated_at: timestamp,
+                vars: {},
+                spec_format: 'steps',
+                steps: [
+                    {
+                        type: 'workflow',
+                        name: 'childWorkflow',
+                        title: 'Review documents',
+                        description: 'Runs the review child workflow',
+                    },
+                ],
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('accepts explicit file, embedding, facet, and data-table wire objects', () => {
+        expect(
+            validateApiResponse('FileMetadataResponse', {
+                name: 'report.pdf',
+                size: 42,
+                contentType: 'application/pdf',
+                generation: '7',
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiResponse('SetObjectEmbeddingsResponse', {
+                type: { model: 'embed-v1', values: [0.1, 0.2], etag: 'abc' },
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiResponse('ComputedFacetResponse', { total: 3, status: [{ _id: 'ready', count: 3 }] }).valid,
+        ).toBe(true);
+        // `total` is reserved for the match count: buckets belong under the facet's own name. The
+        // server rejects a facet named `total` with a 400, so an array can never reach this field.
+        expect(validateApiResponse('ComputedFacetResponse', { total: [{ _id: 'ready', count: 3 }] }).valid).toBe(false);
+        expect(
+            validateApiResponse('DataTable', {
+                name: 'invoices',
+                columns: [{ name: 'id', type: 'STRING' }],
+                tags: [],
+                created_at: timestamp,
+                updated_at: timestamp,
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('accepts workflow memo, children, and interaction snapshots', () => {
+        const workflow = {
+            started_at: timestamp,
+            closed_at: null,
+            initiated_by: 'user:legacy',
+            memo: { InitiatedBy: { data: 'legacy' } },
+        };
+        expect(validateApiResponse('ListWorkflowRunsResponse', { runs: [workflow] }).valid).toBe(true);
+        expect(
+            validateApiResponse('WorkflowRunWithDetails', {
+                ...workflow,
+                children: [{ started_at: timestamp, closed_at: null }],
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiResponse('ListWorkflowInteractionsResponse', {
+                workflow_id: 'workflow-1',
+                run_id: 'run-1',
+                interaction: {
+                    type: 'conversation',
+                    interaction: 'legacy',
+                    interactive: true,
+                    tool_names: [],
+                    config: {
+                        environment: '64b000000000000000000005',
+                        model: 'model',
+                    },
+                    agent_run_id: 'run-1',
+                },
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('accepts record key and value types in the generated activity catalog', () => {
+        expect(
+            validateApiResponse('ActivityCatalog', {
+                activities: [
+                    {
+                        name: 'countByStatus',
+                        title: 'Count By Status',
+                        paramsType: 'CountByStatusParams',
+                        params: [
+                            {
+                                name: 'counts',
+                                optional: false,
+                                type: {
+                                    name: 'record',
+                                    value: 'Record<string, number>',
+                                    keyType: { name: 'string', value: 'string' },
+                                    valueType: { name: 'number', value: 'number' },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            }).valid,
+        ).toBe(true);
+    });
+
+    it('accepts process context, history, and current process definitions', () => {
+        expect(
+            validateApiResponse('ProcessContextResponse', {
+                run_id: 'run-1',
+                current_node: 'review',
+                context: { invoice_id: 'inv-1' },
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiResponse('ProcessHistoryResponse', {
+                run_id: 'run-1',
+                current_node: 'review',
+                node_history: [{ node: 'review', entered_at: timestamp, status: 'running' }],
+                node_history_ref: { path: 'history', latest_sequence: 1, count: 1 },
+            }).valid,
+        ).toBe(true);
+        expect(
+            validateApiResponse('ProcessDefinitionArray', [
+                {
+                    id: '64b000000000000000000008',
+                    account: '64b000000000000000000003',
+                    project: '64b000000000000000000004',
+                    edit_revision: 1,
+                    name: 'Legacy process',
+                    status: 'draft',
+                    version: 1,
+                    definition: {
+                        format_version: 1,
+                        process: 'Process',
+                        initial: 'start',
+                        context: { schema: {}, initial: {} },
+                        nodes: { start: { type: 'final' } },
+                    },
+                    created_at: timestamp,
+                    updated_at: timestamp,
+                    created_by: 'user:legacy',
+                    updated_by: 'user:legacy',
+                },
+            ]).valid,
+        ).toBe(true);
+    });
+});

package/src/apps.test.ts

@@ -4,15 +4,12 @@ import {
     AppEventSubscriptionDefinitionSchema,
     AppPackageHooksSchema,
 } from './api-schemas/app-runtime.js';
-import { APP_ARTIFACT_TYPES, APP_CAPABILITIES, APP_PACKAGE_SCOPES, effectiveAppAccessControl } from './apps.js';
+import { APP_CAPABILITIES, APP_PACKAGE_SCOPES } from './apps.js';
 
 describe('app capability contracts', () => {
-    it('keeps views in manifest, package, and build-artifact contracts', () => {
+    it('keeps views in the manifest and package contracts', () => {
         expect(APP_CAPABILITIES).toContain('views');
         expect(APP_PACKAGE_SCOPES).toContain('views');
-        expect(APP_ARTIFACT_TYPES).toContain('view');
-        expect(APP_ARTIFACT_TYPES).toContain('hook');
-        expect(APP_ARTIFACT_TYPES).toContain('subscription');
     });
 
     it('exposes app hooks as a package query scope', () => {
@@ -90,38 +87,3 @@ describe('app capability contracts', () => {
         });
     });
 });
-
-describe('effectiveAppAccessControl', () => {
-    it("returns 'all' when neither installation nor manifest set the field", () => {
-        expect(effectiveAppAccessControl({}, {})).toBe('all');
-    });
-
-    it("returns 'all' when both inputs are null/undefined", () => {
-        expect(effectiveAppAccessControl(null, null)).toBe('all');
-        expect(effectiveAppAccessControl(undefined, undefined)).toBe('all');
-        expect(effectiveAppAccessControl(null, undefined)).toBe('all');
-    });
-
-    it('falls back to the manifest default when the installation has no override', () => {
-        expect(effectiveAppAccessControl({}, { access_control: 'ui' })).toBe('ui');
-        expect(effectiveAppAccessControl({}, { access_control: 'none' })).toBe('none');
-        expect(effectiveAppAccessControl({}, { access_control: 'all' })).toBe('all');
-    });
-
-    it('lets the installation override the manifest default for all three values', () => {
-        expect(effectiveAppAccessControl({ access_control: 'ui' }, { access_control: 'all' })).toBe('ui');
-        expect(effectiveAppAccessControl({ access_control: 'none' }, { access_control: 'ui' })).toBe('none');
-        expect(effectiveAppAccessControl({ access_control: 'all' }, { access_control: 'none' })).toBe('all');
-    });
-
-    it('treats null arguments the same as undefined', () => {
-        expect(effectiveAppAccessControl(null, { access_control: 'ui' })).toBe('ui');
-        expect(effectiveAppAccessControl({ access_control: 'ui' }, null)).toBe('ui');
-    });
-
-    it('treats null/undefined access_control fields the same as the field being absent', () => {
-        expect(effectiveAppAccessControl({ access_control: undefined }, { access_control: 'ui' })).toBe('ui');
-        // The override accepts AppAccessControl | null at the payload boundary; nullish should fall through.
-        expect(effectiveAppAccessControl({ access_control: undefined }, { access_control: undefined })).toBe('all');
-    });
-});