fix: modify schema after cache

Author: MichalKalita

src/tools/actor.ts

@@ -129,6 +129,7 @@ export async function callActorGetDataset(
  */
 export async function getNormalActorsAsTools(
     actorsInfo: ActorInfo[],
+    fullActorSchema: boolean,
 ): Promise<ToolEntry[]> {
     const tools: ToolEntry[] = [];
 
@@ -139,7 +140,10 @@ export async function getNormalActorsAsTools(
         if (actorDefinitionPruned) {
             const schemaID = getToolSchemaID(actorDefinitionPruned.actorFullName);
             if (actorDefinitionPruned.input && 'properties' in actorDefinitionPruned.input && actorDefinitionPruned.input) {
-                actorDefinitionPruned.input.properties = transformActorInputSchemaProperties(actorDefinitionPruned.input);
+                actorDefinitionPruned.input.properties = transformActorInputSchemaProperties(
+                    actorDefinitionPruned.input,
+                    { separateAdvancedInputs: !fullActorSchema },
+                );
                 // Add schema $id, each valid JSON schema should have a unique $id
                 // see https://json-schema.org/understanding-json-schema/basics#declaring-a-unique-identifier
                 actorDefinitionPruned.input.$id = schemaID;
@@ -219,17 +223,24 @@ export async function getActorsAsTools(
 
     const actorsInfo: (ActorInfo | null)[] = await Promise.all(
         actorIdsOrNames.map(async (actorIdOrName) => {
-            let actorDefinition = actorDefinitionPrunedCache.get(actorIdOrName);
+            // Always cache the full schema version under a stable key
+            const cacheKey = actorIdOrName;
+            let actorDefinition = actorDefinitionPrunedCache.get(cacheKey);
             if (!actorDefinition) {
-                actorDefinition = await getActorDefinition(actorIdOrName, apifyToken, ACTOR_README_MAX_LENGTH, fullActorSchema);
+                actorDefinition = await getActorDefinition(
+                    actorIdOrName,
+                    apifyToken,
+                    ACTOR_README_MAX_LENGTH,
+                );
             }
 
             if (!actorDefinition) {
                 return null;
             }
 
-            // Cache the pruned Actor definition
-            actorDefinitionPrunedCache.set(actorIdOrName, actorDefinition);
+            // Cache canonical full schema without mutation
+            actorDefinitionPrunedCache.set(cacheKey, actorDefinition);
+
             return {
                 actorDefinitionPruned: actorDefinition,
                 webServerMcpPath: getActorMCPServerPath(actorDefinition),
@@ -244,7 +255,7 @@ export async function getActorsAsTools(
     const normalActorsInfo = clonedActors.filter((actorInfo) => actorInfo && !actorInfo.webServerMcpPath) as ActorInfo[];
 
     const [normalTools, mcpServerTools] = await Promise.all([
-        getNormalActorsAsTools(normalActorsInfo),
+        getNormalActorsAsTools(normalActorsInfo, fullActorSchema),
         getMCPServersAsTools(actorMCPServersInfo, apifyToken),
     ]);
 

src/tools/build.ts

@@ -6,14 +6,8 @@ import zodToJsonSchema from 'zod-to-json-schema';
 import log from '@apify/log';
 
 import { ApifyClient } from '../apify-client.js';
-import { ACTOR_README_MAX_LENGTH, ADVANCED_INPUT_KEY, HelperTools } from '../const.js';
-import type {
-    ActorDefinitionPruned,
-    ActorDefinitionWithDesc,
-    InternalTool,
-    ISchemaProperties,
-    ToolEntry,
-} from '../types.js';
+import { ACTOR_README_MAX_LENGTH, HelperTools } from '../const.js';
+import type { ActorDefinitionPruned, InternalTool, ISchemaProperties, ToolEntry } from '../types.js';
 import { filterSchemaProperties, shortenProperties } from './utils.js';
 
 const ajv = new Ajv({ coerceTypes: 'array', strict: false });
@@ -31,7 +25,6 @@ export async function getActorDefinition(
     actorIdOrName: string,
     apifyToken: string,
     limit: number = ACTOR_README_MAX_LENGTH,
-    fullActorSchema = true,
 ): Promise<ActorDefinitionPruned | null> {
     const client = new ApifyClient({ token: apifyToken });
     const actorClient = client.actor(actorIdOrName);
@@ -47,7 +40,7 @@ export async function getActorDefinition(
         const buildDetails = await defaultBuildClient.get();
 
         if (buildDetails?.actorDefinition) {
-            return processActorDefinition(actor, buildDetails.actorDefinition, limit, fullActorSchema);
+            return processActorDefinition(actor, buildDetails.actorDefinition, limit);
         }
         return null;
     } catch (error) {
@@ -60,7 +53,6 @@ export function processActorDefinition(
     actor: Actor,
     definition: ActorDefinition,
     limit: number,
-    fullActorSchema: boolean,
 ): ActorDefinitionPruned {
     let input;
     if (definition?.input && 'type' in definition.input && 'properties' in definition.input) {
@@ -69,9 +61,6 @@ export function processActorDefinition(
             type: definition.input.type as string,
             properties: definition.input.properties as Record<string, ISchemaProperties>,
         };
-        if (!fullActorSchema) {
-            input = separateAdvancedInputs(input);
-        }
     }
     return {
         id: actor.id,
@@ -85,33 +74,6 @@ export function processActorDefinition(
     };
 }
 
-function separateAdvancedInputs(input: ActorDefinitionWithDesc['input']): ActorDefinitionPruned['input'] {
-    if (!input || !input.properties) {
-        return input;
-    }
-
-    const properties = Object.entries(input.properties);
-    const firstSectionCaptionIndex = properties.findIndex(([_key, value]) => value.sectionCaption);
-    if (firstSectionCaptionIndex === -1) {
-        // No advanced inputs, return the input as is
-        return input;
-    }
-
-    // Separate advanced inputs from the main section
-    const mainInputs = properties.slice(0, firstSectionCaptionIndex);
-    const advancedInputs = properties.slice(firstSectionCaptionIndex);
-
-    const propObject = Object.fromEntries(mainInputs);
-    propObject[ADVANCED_INPUT_KEY] = {
-        type: 'object',
-        title: 'Advanced Inputs',
-        description: 'These inputs are considered advanced and are not required for basic functionality.',
-        properties: Object.fromEntries(advancedInputs),
-    };
-
-    return { ...input, properties: propObject };
-}
-
 /** Prune Actor README if it is too long
  * If the README is too long
  * - We keep the README as it is up to the limit.

src/tools/utils.ts

@@ -279,9 +279,19 @@ export function decodeDotPropertyNames(properties: Record<string, unknown>): Rec
     return decodedProperties;
 }
 
-export function transformActorInputSchemaProperties(input: Readonly<IActorInputSchema>): ActorInputSchemaProperties {
+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;
+    }
+
     let transformedProperties = markInputPropertiesAsRequired(inputClone);
     transformedProperties = buildApifySpecificProperties(transformedProperties);
     transformedProperties = filterSchemaProperties(transformedProperties);
@@ -291,3 +301,33 @@ export function transformActorInputSchemaProperties(input: Readonly<IActorInputS
     transformedProperties = encodeDotPropertyNames(transformedProperties);
     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 ?? {};
+    }
+
+    const propertiesEntries = Object.entries(input.properties);
+    const firstSectionCaptionIndex = propertiesEntries.findIndex(([_key, value]) => value.sectionCaption);
+    if (firstSectionCaptionIndex === -1) {
+        return input.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;
+}

src/utils/tools-loader.ts

@@ -4,8 +4,8 @@
  */
 
 import { defaults } from '../const.js';
-import { addRemoveTools, getActorsAsTools, toolCategories } from '../tools/index.js';
 import type { McpOptions } from '../input.js';
+import { addRemoveTools, getActorsAsTools, toolCategories } from '../tools/index.js';
 import type { ToolCategory, ToolEntry } from '../types.js';
 
 /**