fix: tool get-actor-detail returns schema with advanced inputs

Author: MichalKalita

src/tools/get-actor-details.ts

@@ -7,7 +7,7 @@ import { HelperTools } from '../const.js';
 import type { IActorInputSchema, InternalTool, ToolEntry } from '../types.js';
 import { formatActorToActorCard } from '../utils/actor-card.js';
 import { ajv } from '../utils/ajv.js';
-import { filterSchemaProperties, shortenProperties } from './utils.js';
+import { transformActorInputForGetDetails } from './utils.js';
 
 const getActorDetailsToolArgsSchema = z.object({
     actor: z.string()
@@ -31,7 +31,7 @@ export const getActorDetailsTool: ToolEntry = {
         inputSchema: zodToJsonSchema(getActorDetailsToolArgsSchema),
         ajvValidate: ajv.compile(zodToJsonSchema(getActorDetailsToolArgsSchema)),
         call: async (toolArgs) => {
-            const { args, apifyToken } = toolArgs;
+            const { args, apifyToken, apifyMcpServer } = toolArgs;
 
             const parsed = getActorDetailsToolArgsSchema.parse(args);
             const client = new ApifyClient({ token: apifyToken });
@@ -47,12 +47,13 @@ export const getActorDetailsTool: ToolEntry = {
                 };
             }
 
-            const inputSchema = (buildInfo.actorDefinition.input || {
-                type: 'object',
-                properties: {},
-            }) as IActorInputSchema;
-            inputSchema.properties = filterSchemaProperties(inputSchema.properties);
-            inputSchema.properties = shortenProperties(inputSchema.properties);
+            const inputSchema = transformActorInputForGetDetails(
+                (buildInfo.actorDefinition.input || {
+                    type: 'object',
+                    properties: {},
+                }) as IActorInputSchema,
+                { separateAdvancedInputs: !apifyMcpServer.options.fullActorSchema },
+            );
 
             // Use the actor formatter to get the main actor details
             const actorCard = formatActorToActorCard(actorInfo);

src/tools/utils.ts

@@ -279,17 +279,48 @@ export function decodeDotPropertyNames(properties: Record<string, unknown>): Rec
     return decodedProperties;
 }
 
+/**
+ * Separates advanced inputs into a dedicated ADVANCED_INPUT_KEY object based on the first section-captioned property.
+ * The properties from the first section-captioned property onwards are grouped under the advanced input object.
+ */
+export function separateAdvancedInputsInSchema(properties: Record<string, ISchemaProperties>): Record<string, ISchemaProperties> {
+    const propertiesEntries = Object.entries(properties);
+    const firstSectionCaptionIndex = propertiesEntries.findIndex(([_key, value]) => value.sectionCaption);
+    if (firstSectionCaptionIndex === -1) {
+        return properties;
+    }
+
+    const mainInputs = propertiesEntries.slice(0, firstSectionCaptionIndex);
+    const advancedInputs = propertiesEntries.slice(firstSectionCaptionIndex);
+
+    const propObject: Record<string, ISchemaProperties> = Object.fromEntries(mainInputs);
+    // Use a basic object container here; additional details (like title/description) are not required at this stage
+    propObject.advancedInput = {
+        type: 'object',
+        title: 'Advanced Inputs',
+        description: 'These inputs are considered advanced and are not required for basic functionality.',
+        properties: Object.fromEntries(advancedInputs),
+    } as unknown as ISchemaProperties;
+
+    return propObject;
+}
+
 export function transformActorInputSchemaProperties(
     input: Readonly<IActorInputSchema>,
     options?: { separateAdvancedInputs?: boolean },
 ): ActorInputSchemaProperties {
     // Deep clone input to avoid mutating the original object
     const inputClone: IActorInputSchema = structuredClone(input);
 
-    // Optionally separate advanced inputs section into a single ADVANCED_INPUT_KEY object
     if (options?.separateAdvancedInputs) {
-        const separated = separateAdvancedInputsInSchema(inputClone);
-        inputClone.properties = separated;
+        inputClone.properties = separateAdvancedInputsInSchema(inputClone.properties);
+        if (inputClone.properties.advancedInput) {
+            // Recursively transform the advanced input properties
+            inputClone.properties.advancedInput.properties = transformActorInputSchemaProperties(
+                inputClone.properties.advancedInput as IActorInputSchema,
+                { separateAdvancedInputs: false },
+            );
+        }
     }
 
     let transformedProperties = markInputPropertiesAsRequired(inputClone);
@@ -302,32 +333,25 @@ export function transformActorInputSchemaProperties(
     return transformedProperties;
 }
 
-/**
- * Separates advanced inputs into a dedicated ADVANCED_INPUT_KEY object based on the first section-captioned property.
- * The properties from the first section-captioned property onwards are grouped under the advanced input object.
- */
-export function separateAdvancedInputsInSchema(input: IActorInputSchema): Record<string, ISchemaProperties> {
-    if (!input || !input.properties) {
-        return input.properties ?? {};
-    }
+export function transformActorInputForGetDetails(
+    input: Readonly<IActorInputSchema>,
+    options?: { separateAdvancedInputs?: boolean },
+) {
+    // Deep clone input to avoid mutating the original object
+    const inputClone = structuredClone(input) as IActorInputSchema;
 
-    const propertiesEntries = Object.entries(input.properties);
-    const firstSectionCaptionIndex = propertiesEntries.findIndex(([_key, value]) => value.sectionCaption);
-    if (firstSectionCaptionIndex === -1) {
-        return input.properties;
+    if (options?.separateAdvancedInputs) {
+        inputClone.properties = separateAdvancedInputsInSchema(inputClone.properties);
+        if (inputClone.properties.advancedInput) {
+            // Recursively transform the advanced input properties
+            inputClone.properties.advancedInput = transformActorInputForGetDetails(
+                inputClone.properties.advancedInput as IActorInputSchema,
+                { separateAdvancedInputs: false },
+            ) as ISchemaProperties;
+        }
     }
 
-    const mainInputs = propertiesEntries.slice(0, firstSectionCaptionIndex);
-    const advancedInputs = propertiesEntries.slice(firstSectionCaptionIndex);
-
-    const propObject: Record<string, ISchemaProperties> = Object.fromEntries(mainInputs);
-    // Use a basic object container here; additional details (like title/description) are not required at this stage
-    propObject.advancedInput = {
-        type: 'object',
-        title: 'Advanced Inputs',
-        description: 'These inputs are considered advanced and are not required for basic functionality.',
-        properties: Object.fromEntries(advancedInputs),
-    } as unknown as ISchemaProperties;
-
-    return propObject;
+    inputClone.properties = filterSchemaProperties(inputClone.properties);
+    inputClone.properties = shortenProperties(inputClone.properties);
+    return inputClone;
 }

tests/unit/tools.utils.test.ts

@@ -786,4 +786,57 @@ describe('transformActorInputSchemaProperties', () => {
         transformActorInputSchemaProperties(input);
         expect(input).toEqual(inputCopy);
     });
+
+    it('should separate advanced inputs', () => {
+        const input = {
+            title: 'Test',
+            type: 'object',
+            required: ['query'],
+            properties: {
+                query: {
+                    type: 'string',
+                    title: 'Query',
+                    description: 'Query desc',
+                },
+                special: {
+                    type: 'string',
+                    title: 'Special',
+                    description: 'Special desc',
+                    sectionCaption: 'Special',
+                },
+                another: {
+                    type: 'string',
+                    title: 'Another',
+                    description: 'Another desc',
+                },
+            },
+        };
+        const result = transformActorInputSchemaProperties(input, { separateAdvancedInputs: true });
+        expect(JSON.stringify(result, null, 2)).toMatchInlineSnapshot(`
+          "{
+            "query": {
+              "title": "Query",
+              "description": "**REQUIRED** Query desc",
+              "type": "string"
+            },
+            "advancedInput": {
+              "title": "Advanced Inputs",
+              "description": "These inputs are considered advanced and are not required for basic functionality.",
+              "type": "object",
+              "properties": {
+                "special": {
+                  "title": "Special",
+                  "description": "Special desc",
+                  "type": "string"
+                },
+                "another": {
+                  "title": "Another",
+                  "description": "Another desc",
+                  "type": "string"
+                }
+              }
+            }
+          }"
+        `);
+    });
 });