fix: Stop enforcing enum values dropped by input-schema truncation

shortenProperties() truncates a large enum for display, but the same
truncated array was also compiled straight into the AJV validator —
rejecting Actor input values that were cut only because the display
list has a character cap, not because the Actor's real schema forbids
them (e.g. compass/crawler-google-places' categoryFilterWords).

Strip enum/items.enum from the AJV-compiled schema only for properties
where truncation actually happened, comparing against the raw Actor
schema. The schema shown to the LLM keeps the truncated list unchanged
— only local enforcement of the incomplete list is removed.

Closes #1253.

Written with AI assistance (Claude).

Author: MQ37

src/tools/actor_input_schema.ts

@@ -365,6 +365,46 @@ export function decodeDotPropertyNames(properties: Record<string, unknown>): Rec
     return decodedProperties;
 }
 
+/**
+ * True if filterAndShortenEnum() truncated the enum — compared against the non-empty raw count,
+ * not raw length, since it also drops blank entries regardless of the character cap.
+ */
+function wasEnumTruncated(displayEnum: string[], rawEnum: string[]): boolean {
+    const nonEmptyRawCount = rawEnum.filter((value) => value !== '').length;
+    return displayEnum.length < nonEmptyRawCount;
+}
+
+/**
+ * Clones properties and drops `enum`/`items.enum` wherever shortenProperties() truncated it —
+ * AJV must not enforce an incomplete list (#1253), but the schema shown to the LLM keeps it.
+ * A property missing from one side (e.g. the injected `waitSecs`) is left untouched.
+ */
+export function stripTruncatedEnumsForValidation(
+    displayProperties: Record<string, SchemaProperties>,
+    rawProperties: Record<string, SchemaProperties>,
+): Record<string, SchemaProperties> {
+    const rawEncoded = encodeDotPropertyNames(rawProperties);
+    const validationProperties = structuredClone(displayProperties);
+
+    for (const [key, property] of Object.entries(validationProperties)) {
+        const rawProperty = rawEncoded[key];
+        if (!rawProperty) continue;
+
+        if (property.enum && rawProperty.enum && wasEnumTruncated(property.enum, rawProperty.enum)) {
+            delete property.enum;
+        }
+        if (
+            property.items?.enum &&
+            rawProperty.items?.enum &&
+            wasEnumTruncated(property.items.enum, rawProperty.items.enum)
+        ) {
+            delete property.items.enum;
+        }
+    }
+
+    return validationProperties;
+}
+
 export function transformActorInputSchemaProperties(input: Readonly<ActorInputSchema>): ActorInputSchemaProperties {
     // Deep clone input to avoid mutating the original object
     const inputClone: ActorInputSchema = structuredClone(input);

src/tools/actors/actor_tools_factory.ts

@@ -20,6 +20,7 @@ import {
     type ActorStore,
     type ActorTool,
     type ApifyToken,
+    type SchemaProperties,
     type ToolEntry,
     type ToolInputSchema,
     TOOL_TYPE,
@@ -28,7 +29,7 @@ import { getActorDefinitionCached } from '../../utils/actor.js';
 import { ajv } from '../../utils/ajv.js';
 import { stripQuoteWrappers } from '../../utils/generic.js';
 import { logHttpError } from '../../utils/logging.js';
-import { buildActorInputSchema, fixedAjvCompile } from '../actor_input_schema.js';
+import { buildActorInputSchema, fixedAjvCompile, stripTruncatedEnumsForValidation } from '../actor_input_schema.js';
 import { actorNameToToolName, isActorBlockedUnderPaymentProvider, isActorInfoMcpServer } from '../actor_tool_naming.js';
 import { buildEnrichedDirectActorOutputSchema, actorRunOutputSchema } from '../structured_output_schemas.js';
 import { CALL_ACTOR_WAIT_SECS_DEFAULT, WAIT_SECS_MAX } from './actor_run_response.js';
@@ -133,12 +134,21 @@ Actor description: ${definition.description}`;
             ACTOR_MAX_MEMORY_MBYTES,
         );
 
+        // AJV must not enforce a truncated enum (#1253) — definition.input still has the full one.
+        const validationSchema = {
+            ...inputSchema,
+            properties: stripTruncatedEnumsForValidation(
+                (inputSchemaWithWaitSecs.properties ?? {}) as Record<string, SchemaProperties>,
+                definition.input?.properties ?? {},
+            ),
+        };
+
         let ajvValidate;
         try {
             // Unknown properties are silently stripped by AJV's removeAdditional option.
             // Dynamic Actor input fields are part of the Actor's own inputSchema, so they
             // are declared properties and won't be stripped.
-            ajvValidate = fixedAjvCompile(ajv, inputSchema);
+            ajvValidate = fixedAjvCompile(ajv, validationSchema);
         } catch (e) {
             // SchemaTooLargeError logs as a soft fail; a genuine AJV compile error stays an error.
             logHttpError(e, 'Failed to compile schema', {

tests/unit/tools.utils.test.ts

@@ -14,6 +14,7 @@ import {
     MAX_UNTRUSTED_SCHEMA_BYTES,
     markInputPropertiesAsRequired,
     shortenProperties,
+    stripTruncatedEnumsForValidation,
     transformActorInputSchemaProperties,
 } from '../../src/tools/actor_input_schema.js';
 import { isActorBlockedUnderPaymentProvider } from '../../src/tools/actor_tool_naming.js';
@@ -499,6 +500,95 @@ describe('shortenProperties', () => {
     });
 });
 
+describe('stripTruncatedEnumsForValidation', () => {
+    it('keeps enum unchanged when it fits comfortably under the cap on both sides', () => {
+        const display: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: ['a', 'b'] },
+        };
+        const raw: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: ['a', 'b'] },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, raw);
+
+        expect(result.prop1.enum).toEqual(['a', 'b']);
+    });
+
+    it('strips enum entirely when it was truncated by shortenProperties', () => {
+        const rawEnum = Array.from({ length: 300 }, (_, i) => `value-${i}`);
+        const display: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: filterAndShortenEnum(rawEnum) },
+        };
+        const raw: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: rawEnum },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, raw);
+
+        expect(result.prop1.enum).toBeUndefined();
+    });
+
+    it('strips items.enum entirely when it was truncated (the #1253 shape), leaving other items fields untouched', () => {
+        const rawEnum = Array.from({ length: 300 }, (_, i) => `value-${i}`);
+        const display: Record<string, SchemaProperties> = {
+            prop1: {
+                type: 'array',
+                title: 'Prop 1',
+                description: 'desc',
+                items: { type: 'string', title: 'Item', description: 'Item desc', enum: filterAndShortenEnum(rawEnum) },
+            },
+        };
+        const raw: Record<string, SchemaProperties> = {
+            prop1: {
+                type: 'array',
+                title: 'Prop 1',
+                description: 'desc',
+                items: { type: 'string', title: 'Item', description: 'Item desc', enum: rawEnum },
+            },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, raw);
+
+        expect(result.prop1.items?.enum).toBeUndefined();
+        expect(result.prop1.items?.type).toBe('string');
+        expect(result.prop1.items?.title).toBe('Item');
+    });
+
+    it('does not treat empty-string removal as truncation when non-empty count never exceeds the cap', () => {
+        const rawEnum = ['a', 'b', '', '', 'c'];
+        const display: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: filterAndShortenEnum(rawEnum) },
+        };
+        const raw: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: rawEnum },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, raw);
+
+        expect(result.prop1.enum).toEqual(['a', 'b', 'c']);
+    });
+
+    it('leaves a property with no counterpart in rawProperties untouched (e.g. the injected waitSecs)', () => {
+        const display: Record<string, SchemaProperties> = {
+            waitSecs: { type: 'integer', title: 'Wait seconds', description: 'desc' },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, {});
+
+        expect(result).toEqual(display);
+    });
+
+    it('is a safe no-op when rawProperties is empty', () => {
+        const display: Record<string, SchemaProperties> = {
+            prop1: { type: 'string', title: 'Prop 1', description: 'desc', enum: ['a', 'b'] },
+        };
+
+        const result = stripTruncatedEnumsForValidation(display, {});
+
+        expect(result).toEqual(display);
+    });
+});
+
 describe('encodeDotPropertyNames', () => {
     it('should replace dots in property names with -dot-', () => {
         const input = {
@@ -1035,6 +1125,49 @@ describe('buildActorInputSchema + getToolPublicFieldOnly pipeline', () => {
         expect(schema.properties?.query?.description).toMatch(/^\*\*REQUIRED\*\*/);
         expect(schema.properties?.maxResults?.description).not.toMatch(/^\*\*REQUIRED\*\*/);
     });
+
+    // Regression: #1253 — a value cut only by display truncation must still pass AJV.
+    it('accepts an enum value dropped by display truncation, while the displayed schema keeps the truncated list', () => {
+        // 'kept-0' is short and sorts first, so it always survives filterAndShortenEnum's cap;
+        // 'dropped-value' is padded long enough to land well past the cap.
+        const keptValue = 'kept-0';
+        const droppedValue = 'dropped-value-cut-by-truncation';
+        const rawEnum = [
+            keptValue,
+            ...Array.from({ length: 300 }, (_, i) => `kept-padding-${i}-${'x'.repeat(20)}`),
+            droppedValue,
+        ];
+        const upstream: ActorInputSchema = {
+            type: 'object',
+            properties: {
+                categoryFilterWords: {
+                    type: 'string',
+                    title: 'Category',
+                    description: 'Category filter word.',
+                    enum: rawEnum,
+                },
+            },
+            required: [],
+        };
+
+        const { inputSchema } = buildActorInputSchema('compass/crawler-google-places', upstream, false);
+        const displayProperties = inputSchema.properties as Record<string, SchemaProperties>;
+
+        // Display schema still shows the truncated enum, unaffected by the fix.
+        const displayEnum = displayProperties.categoryFilterWords.enum;
+        expect(displayEnum).toBeDefined();
+        expect(displayEnum!.length).toBeGreaterThan(0);
+        expect(displayEnum!.length).toBeLessThan(rawEnum.length);
+        expect(displayEnum).not.toContain(droppedValue);
+
+        // AJV accepts the dropped value — the #1253 repro (categoryFilterWords: ['restaurant']).
+        const validationSchema = {
+            ...inputSchema,
+            properties: stripTruncatedEnumsForValidation(displayProperties, upstream.properties),
+        };
+        const validate = fixedAjvCompile(ajv, validationSchema);
+        expect(validate({ categoryFilterWords: droppedValue })).toBe(true);
+    });
 });
 
 describe('isActorBlockedUnderPaymentProvider', () => {