fix output tool, write test for that

Author: MQ37

src/tools/get-actor-output.ts

@@ -102,11 +102,14 @@ You also can retrieve only specific fields from the output if needed. Use this t
                 return { content: [{ type: 'text', text: `Dataset '${parsed.datasetId}' not found.` }] };
             }
 
+            let { items } = response;
             // Apply field selection if specified
-            const processedItems = response.items.map((item) => getValuesByDotKeys(item, fieldsArray));
+            if (fieldsArray.length > 0) {
+                items = items.map((item) => getValuesByDotKeys(item, fieldsArray));
+            }
 
             // Clean empty properties
-            const cleanedItems = processedItems
+            const cleanedItems = items
                 .map((item) => cleanEmptyProperties(item))
                 .filter((item) => item !== undefined);
 

src/utils/actor.ts

@@ -39,16 +39,24 @@ export function ensureOutputWithinCharLimit(items: DatasetItem[], importantField
         return items;
     }
 
+    /**
+     * Items used for the final fallback - removing items until within the limit.
+     * If important fields are defined, use only those fields for that fallback step.
+     */
+    let sourceItems = items;
     // Try only the important fields
-    const importantItems = items.map((item) => getValuesByDotKeys(item, importantFields));
-    const importantItemsString = JSON.stringify(importantItems);
-    if (importantItemsString.length <= charLimit) {
-        return importantItems;
+    if (importantFields.length > 0) {
+        const importantItems = items.map((item) => getValuesByDotKeys(item, importantFields));
+        const importantItemsString = JSON.stringify(importantItems);
+        if (importantItemsString.length <= charLimit) {
+            return importantItems;
+        }
+        sourceItems = importantItems;
     }
 
     // Start removing items until within the limit
     const result: DatasetItem[] = [];
-    for (const item of importantItems) {
+    for (const item of sourceItems) {
         if (JSON.stringify(result.concat(item)).length > charLimit) {
             break;
         }

src/utils/generic.ts

@@ -8,7 +8,7 @@
  * const value = getValuesByDotKeys(obj, ['a.b.c', 'a.b.d', 'nested']);
  * value; // { 'a.b.c': 42, 'a.b.d': undefined, 'nested': { d: 100 } }
  */
-export function getValuesByDotKeys<T extends object>(obj: T, keys: string[]): Record<string, unknown> {
+export function getValuesByDotKeys(obj: Record<string, unknown>, keys: string[]): Record<string, unknown> {
     const result: Record<string, unknown> = {};
     for (const key of keys) {
         const path = key.split('.');

tests/integration/suite.ts

@@ -870,5 +870,45 @@ export function createIntegrationTestsSuite(
 
             await client.close();
         });
+
+        it('should call apify/python-example and retrieve the full dataset using get-actor-output tool', async () => {
+            client = await createClientFn({ actors: ['apify/python-example'] });
+            const selectedToolName = actorNameToToolName('apify/python-example');
+            const input = { first_number: 5, second_number: 7 };
+
+            const result = await client.callTool({
+                name: selectedToolName,
+                arguments: input,
+            });
+
+            expect(result.content).toBeDefined();
+            const content = result.content as { text: string; type: string }[];
+            expect(content.length).toBe(2); // Call step returns text summary with embedded schema
+
+            // First content: text summary
+            const runText = content[0].text;
+
+            // Extract datasetId from the text
+            const runIdMatch = runText.match(/Run ID: ([^\n]+)\n• Dataset ID: ([^\n]+)/);
+            expect(runIdMatch).toBeTruthy();
+            const datasetId = runIdMatch![2];
+
+            // Retrieve full dataset using get-actor-output tool
+            const outputResult = await client.callTool({
+                name: HelperTools.ACTOR_OUTPUT_GET,
+                arguments: {
+                    datasetId,
+                },
+            });
+
+            expect(outputResult.content).toBeDefined();
+            const outputContent = outputResult.content as { text: string; type: string }[];
+            const output = JSON.parse(outputContent[0].text);
+            expect(Array.isArray(output)).toBe(true);
+            expect(output.length).toBe(1);
+            expect(output[0]).toHaveProperty('first_number', input.first_number);
+            expect(output[0]).toHaveProperty('second_number', input.second_number);
+            expect(output[0]).toHaveProperty('sum', input.first_number + input.second_number);
+        });
     });
 }