Return only relevant output dataset properies if defined in storage views defiintion, if dump all properties. Fix input schema for Actors without any input schema.

MQ37 · MQ37 · commit 4696373f6561 · 2025-07-04T17:07:12.000+02:00
diff --git a/src/const.ts b/src/const.ts
@@ -46,13 +46,7 @@ export const ACTOR_OUTPUT_MAX_CHARS_PER_ITEM = 5_000;
 export const ACTOR_OUTPUT_TRUNCATED_MESSAGE = `Output was truncated because it will not fit into context.`
     + `There is no reason to call this tool again! You can use ${HelperTools.DATASET_GET_ITEMS} tool to get more items from the dataset.`;
 
-export const ACTOR_ADDITIONAL_INSTRUCTIONS = `Never call/execute tool/Actor unless confirmed by the user.
-     Workflow: When an Actor runs, it processes data and stores results in Apify storage,
-     Datasets (for structured/tabular data) and Key-Value Store (for various data types like JSON, images, HTML).
-     Each Actor run produces a dataset ID and key-value store ID for accessing the results.
-     By default, the number of items returned from an Actor run is limited to ${ACTOR_RUN_DATASET_OUTPUT_MAX_ITEMS}.
-     You can always use ${HelperTools.DATASET_GET_ITEMS} tool to get more items from the dataset.
-     Actor run input is always stored in the key-value store, recordKey: INPUT.`;
+export const ACTOR_ADDITIONAL_INSTRUCTIONS = 'Never call/execute tool/Actor unless confirmed by the user.';
 
 export const ACTOR_CACHE_MAX_SIZE = 500;
 export const ACTOR_CACHE_TTL_SECS = 30 * 60; // 30 minutes
diff --git a/src/main.ts b/src/main.ts
@@ -56,10 +56,10 @@ if (STANDBY_MODE) {
         await Actor.fail('If you need to debug a specific Actor, please provide the debugActor and debugActorInput fields in the input');
     }
     const options = { memory: input.maxActorMemoryBytes } as ActorCallOptions;
-    const { datasetInfo, items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, process.env.APIFY_TOKEN, options);
+    const { items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, process.env.APIFY_TOKEN, options);
 
     await Actor.pushData(items);
-    log.info(`Pushed ${datasetInfo?.itemCount} items to the dataset`);
+    log.info(`Pushed ${items.count} items to the dataset`);
     await Actor.exit();
 }
 
diff --git a/src/mcp/server.ts b/src/mcp/server.ts
@@ -19,8 +19,6 @@ import { type ActorCallOptions, ApifyApiError } from 'apify-client';
 import log from '@apify/log';
 
 import {
-    ACTOR_OUTPUT_MAX_CHARS_PER_ITEM,
-    ACTOR_OUTPUT_TRUNCATED_MESSAGE,
     defaults,
     SERVER_NAME,
     SERVER_VERSION,
@@ -468,25 +466,20 @@ export class ActorsMcpServer {
                     const actorTool = tool.tool as ActorTool;
 
                     const callOptions: ActorCallOptions = { memory: actorTool.memoryMbytes };
-                    const { actorRun, datasetInfo, items } = await callActorGetDataset(
+                    const { items } = await callActorGetDataset(
                         actorTool.actorFullName,
                         args,
                         apifyToken as string,
                         callOptions,
                     );
-                    const content = [
-                        { type: 'text', text: `Actor finished with run information: ${JSON.stringify(actorRun)}` },
-                        { type: 'text', text: `Dataset information: ${JSON.stringify(datasetInfo)}` },
-                    ];
-
-                    const itemContents = items.items.map((item: Record<string, unknown>) => {
-                        const text = JSON.stringify(item).slice(0, ACTOR_OUTPUT_MAX_CHARS_PER_ITEM);
-                        return text.length === ACTOR_OUTPUT_MAX_CHARS_PER_ITEM
-                            ? { type: 'text', text: `${text} ... ${ACTOR_OUTPUT_TRUNCATED_MESSAGE}` }
-                            : { type: 'text', text };
-                    });
-                    content.push(...itemContents);
-                    return { content };
+                    return {
+                        content: items.items.map((item: Record<string, unknown>) => {
+                            return {
+                                type: 'text',
+                                text: JSON.stringify(item),
+                            };
+                        }),
+                    };
                 }
             } catch (error) {
                 if (error instanceof ApifyApiError) {
diff --git a/src/tools/actor.ts b/src/tools/actor.ts
@@ -1,6 +1,6 @@
 import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { Ajv } from 'ajv';
-import type { ActorCallOptions, ActorRun, Dataset, PaginatedList } from 'apify-client';
+import type { ActorCallOptions, ActorRun, PaginatedList } from 'apify-client';
 import { z } from 'zod';
 import zodToJsonSchema from 'zod-to-json-schema';
 
@@ -10,14 +10,15 @@ import { ApifyClient } from '../apify-client.js';
 import {
     ACTOR_ADDITIONAL_INSTRUCTIONS,
     ACTOR_MAX_MEMORY_MBYTES,
-    ACTOR_RUN_DATASET_OUTPUT_MAX_ITEMS,
     HelperTools,
 } from '../const.js';
 import { getActorMCPServerPath, getActorMCPServerURL } from '../mcp/actors.js';
 import { connectMCPClient } from '../mcp/client.js';
 import { getMCPServerTools } from '../mcp/proxy.js';
 import { actorDefinitionPrunedCache } from '../state.js';
-import type { ActorInfo, InternalTool, ToolEntry } from '../types.js';
+import type { ActorDefinitionStorage, ActorInfo, InternalTool, ToolEntry } from '../types.js';
+import { getActorDefinitionStorageFieldNames } from '../utils/actor.js';
+import { getValuesByDotKeys } from '../utils/generic.js';
 import { getActorDefinition } from './build.js';
 import {
     actorNameToToolName,
@@ -34,8 +35,6 @@ const ajv = new Ajv({ coerceTypes: 'array', strict: false });
 
 // Define a named return type for callActorGetDataset
 export type CallActorGetDatasetResult = {
-    actorRun: ActorRun;
-    datasetInfo: Dataset | undefined;
     items: PaginatedList<Record<string, unknown>>;
 };
 
@@ -50,7 +49,6 @@ export type CallActorGetDatasetResult = {
  * @param {ActorCallOptions} callOptions - The options to pass to the actor.
  * @param {unknown} input - The input to pass to the actor.
  * @param {string} apifyToken - The Apify token to use for authentication.
- * @param {number} limit - The maximum number of items to retrieve from the dataset.
  * @returns {Promise<{ actorRun: any, items: object[] }>} - A promise that resolves to an object containing the actor run and dataset items.
  * @throws {Error} - Throws an error if the `APIFY_TOKEN` is not set
  */
@@ -59,7 +57,6 @@ export async function callActorGetDataset(
     input: unknown,
     apifyToken: string,
     callOptions: ActorCallOptions | undefined = undefined,
-    limit = ACTOR_RUN_DATASET_OUTPUT_MAX_ITEMS,
 ): Promise<CallActorGetDatasetResult> {
     try {
         log.info(`Calling Actor ${actorName} with input: ${JSON.stringify(input)}`);
@@ -69,13 +66,24 @@ export async function callActorGetDataset(
 
         const actorRun: ActorRun = await actorClient.call(input, callOptions);
         const dataset = client.dataset(actorRun.defaultDatasetId);
-        const [datasetInfo, items] = await Promise.all([
-            dataset.get(),
-            dataset.listItems({ limit }),
+        // const dataset = client.dataset('Ehtn0Y4wIKviFT2WB');
+        const [items, defaultBuild] = await Promise.all([
+            dataset.listItems(),
+            (await actorClient.defaultBuild()).get(),
         ]);
-        log.info(`Actor ${actorName} finished with ${datasetInfo?.itemCount} items`);
 
-        return { actorRun, datasetInfo, items };
+        // Get important properties from storage view definitions and if available return only those properties
+        const storageDefinition = defaultBuild?.actorDefinition?.storages?.dataset as ActorDefinitionStorage | undefined;
+        const importantProperties = getActorDefinitionStorageFieldNames(storageDefinition || {});
+        if (importantProperties.length > 0) {
+            items.items = items.items.map((item) => {
+                return getValuesByDotKeys(item, importantProperties);
+            });
+        }
+
+        log.info(`Actor ${actorName} finished with ${items.count} items`);
+
+        return { items };
     } catch (error) {
         log.error(`Error calling actor: ${error}. Actor: ${actorName}, input: ${JSON.stringify(input)}`);
         throw new Error(`Error calling Actor: ${error}`);
@@ -132,7 +140,13 @@ export async function getNormalActorsAsTools(
                         name: actorNameToToolName(actorDefinitionPruned.actorFullName),
                         actorFullName: actorDefinitionPruned.actorFullName,
                         description: `${actorDefinitionPruned.description} Instructions: ${ACTOR_ADDITIONAL_INSTRUCTIONS}`,
-                        inputSchema: actorDefinitionPruned.input || {},
+                        inputSchema: actorDefinitionPruned.input
+                        // So Actor without input schema works - MCP client expects JSON schema valid output
+                        || {
+                            type: 'object',
+                            properties: {},
+                            required: [],
+                        },
                         ajvValidate: fixedAjvCompile(ajv, actorDefinitionPruned.input || {}),
                         memoryMbytes: memoryMbytes > ACTOR_MAX_MEMORY_MBYTES ? ACTOR_MAX_MEMORY_MBYTES : memoryMbytes,
                     },
diff --git a/src/types.ts b/src/types.ts
@@ -241,3 +241,20 @@ export type ExtendedActorStoreList = ActorStoreList & {
     bookmarkCount?: number;
     actorReviewRating?: number;
 };
+
+export type ActorDefinitionStorage = {
+    views: Record<
+        string,
+        {
+            transformation: {
+                fields?: string[];
+            };
+            display: {
+                properties: Record<
+                    string,
+                    object
+                >;
+            };
+        }
+    >;
+};
diff --git a/src/utils/actor.ts b/src/utils/actor.ts
@@ -0,0 +1,24 @@
+import type { ActorDefinitionStorage } from '../types.js';
+
+/**
+ * Returns an array of all field names mentioned in the display.properties
+ * of all views in the given ActorDefinitionStorage object.
+ */
+export function getActorDefinitionStorageFieldNames(storage: ActorDefinitionStorage | object): string[] {
+    const fieldSet = new Set<string>();
+    if ('views' in storage && typeof storage.views === 'object' && storage.views !== null) {
+        for (const view of Object.values(storage.views)) {
+            // Collect from display.properties
+            if (view.display && view.display.properties) {
+                Object.keys(view.display.properties).forEach((field) => fieldSet.add(field));
+            }
+            // Collect from transformation.fields
+            if (view.transformation && Array.isArray(view.transformation.fields)) {
+                view.transformation.fields.forEach((field) => {
+                    if (typeof field === 'string') fieldSet.add(field);
+                });
+            }
+        }
+    }
+    return Array.from(fieldSet);
+}
diff --git a/src/utils/generic.ts b/src/utils/generic.ts
@@ -0,0 +1,27 @@
+/**
+ * Recursively gets the value in a nested object for each key in the keys array.
+ * Each key can be a dot-separated path (e.g. 'a.b.c').
+ * Returns an object mapping each key to its resolved value (or undefined if not found).
+ */
+export function getValuesByDotKeys<T extends object>(obj: T, keys: string[]): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+        const path = key.split('.');
+        let current: unknown = obj;
+        for (const segment of path) {
+            if (
+                current !== null
+                && typeof current === 'object'
+                && Object.prototype.hasOwnProperty.call(current, segment)
+            ) {
+                // Use index signature to avoid 'any' and type errors
+                current = (current as Record<string, unknown>)[segment];
+            } else {
+                current = undefined;
+                break;
+            }
+        }
+        result[key] = current;
+    }
+    return result;
+}
diff --git a/tests/integration/suite.ts b/tests/integration/suite.ts
@@ -40,14 +40,18 @@ async function callPythonExampleActor(client: Client, selectedToolName: string)
     type ContentItem = { text: string; type: string };
     const content = result.content as ContentItem[];
     // The result is { content: [ ... ] }, and the last content is the sum
-    expect(content[content.length - 1]).toEqual({
+    const expected = {
         text: JSON.stringify({
             first_number: 1,
             second_number: 2,
             sum: 3,
         }),
         type: 'text',
-    });
+    };
+    // Parse the JSON to compare objects regardless of property order
+    const actual = content[content.length - 1];
+    expect(JSON.parse(actual.text)).toEqual(JSON.parse(expected.text));
+    expect(actual.type).toBe(expected.type);
 }
 
 export function createIntegrationTestsSuite(
diff --git a/tests/unit/utils.actor.test.ts b/tests/unit/utils.actor.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+
+import { getActorDefinitionStorageFieldNames } from '../../src/utils/actor.js';
+
+describe('getActorDefinitionStorageFieldNames', () => {
+    it('should return an array of field names from a single view (display.properties and transformation.fields)', () => {
+        const storage = {
+            views: {
+                view1: {
+                    display: {
+                        properties: {
+                            foo: {},
+                            bar: {},
+                            baz: {},
+                        },
+                    },
+                    transformation: {
+                        fields: ['baz', 'qux', 'extra'],
+                    },
+                },
+            },
+        };
+        const result = getActorDefinitionStorageFieldNames(storage);
+        expect(result.sort()).toEqual(['bar', 'baz', 'extra', 'foo', 'qux']);
+    });
+
+    it('should return unique field names from multiple views (display.properties and transformation.fields)', () => {
+        const storage = {
+            views: {
+                view1: {
+                    display: {
+                        properties: {
+                            foo: {},
+                            bar: {},
+                        },
+                    },
+                    transformation: {
+                        fields: ['foo', 'alpha'],
+                    },
+                },
+                view2: {
+                    display: {
+                        properties: {
+                            bar: {},
+                            baz: {},
+                        },
+                    },
+                    transformation: {
+                        fields: ['baz', 'beta', 'alpha'],
+                    },
+                },
+            },
+        };
+        const result = getActorDefinitionStorageFieldNames(storage);
+        expect(result.sort()).toEqual(['alpha', 'bar', 'baz', 'beta', 'foo']);
+    });
+
+    it('should return an empty array if no properties or fields are present', () => {
+        const storage = {
+            views: {
+                view1: {
+                    display: {
+                        properties: {},
+                    },
+                    transformation: {
+                        fields: [],
+                    },
+                },
+            },
+        };
+        const result = getActorDefinitionStorageFieldNames(storage);
+        expect(result).toEqual([]);
+    });
+
+    it('should handle empty views object', () => {
+        const storage = { views: {} };
+        const result = getActorDefinitionStorageFieldNames(storage);
+        expect(result).toEqual([]);
+    });
+
+    it('should handle missing transformation or display', () => {
+        const storage = {
+            views: {
+                view1: {
+                    display: {
+                        properties: { foo: {} },
+                    },
+                },
+                view2: {
+                    transformation: {
+                        fields: ['bar', 'baz'],
+                    },
+                },
+                view3: {},
+            },
+        };
+        const result = getActorDefinitionStorageFieldNames(storage);
+        expect(result.sort()).toEqual(['bar', 'baz', 'foo']);
+    });
+});
diff --git a/tests/unit/utils.generic.test.ts b/tests/unit/utils.generic.test.ts

Original file line number	Diff line number	Diff line change
`@@ -56,10 +56,10 @@ if (STANDBY_MODE) {`
`56`	`56`	`await Actor.fail('If you need to debug a specific Actor, please provide the debugActor and debugActorInput fields in the input');`
`57`	`57`	`}`
`58`	`58`	`const options = { memory: input.maxActorMemoryBytes } as ActorCallOptions;`
`59`		`- const { datasetInfo, items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, process.env.APIFY_TOKEN, options);`
	`59`	`+ const { items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, process.env.APIFY_TOKEN, options);`
`60`	`60`
`61`	`61`	`await Actor.pushData(items);`
`62`		- log.info(`Pushed ${datasetInfo?.itemCount} items to the dataset`);
	`62`	+ log.info(`Pushed ${items.count} items to the dataset`);
`63`	`63`	`await Actor.exit();`
`64`	`64`	`}`
`65`	`65`