feat(coder): turn 1/2 for #1160

Author: apify-factory

src/tools/runs/get_actor_run_log.ts

@@ -4,7 +4,8 @@ import { HELPER_TOOLS } from '../../const.js';
 import type { InternalToolArgs, ToolEntry, ToolInputSchema } from '../../types.js';
 import { TOOL_TYPE } from '../../types.js';
 import { compileSchema } from '../../utils/ajv.js';
-import { respondRaw } from '../../utils/mcp.js';
+import { respondOk } from '../../utils/mcp.js';
+import { getActorRunLogToolOutputSchema } from '../structured_output_schemas.js';
 
 const GetRunLogArgs = z.object({
     runId: z.string().describe('The ID of the Actor run.'),
@@ -29,9 +30,7 @@ USAGE EXAMPLES:
 - user_input: Show last 20 lines of logs for run y2h7sK3Wc
 - user_input: Get logs for run y2h7sK3Wc`,
     inputSchema: z.toJSONSchema(GetRunLogArgs) as ToolInputSchema,
-    // It does not make sense to add structured output here since the log API just returns plain text
-    // TODO(#1160): no `outputSchema`, so the `tools/call` result projection against an advertised
-    // schema does not apply to this tool either way.
+    outputSchema: getActorRunLogToolOutputSchema,
     ajvValidate: compileSchema(z.toJSONSchema(GetRunLogArgs)),
     paymentRequired: true,
     annotations: {
@@ -47,6 +46,6 @@ USAGE EXAMPLES:
         const v = (await client.run(parsed.runId).log().get()) ?? '';
         const lines = v.split('\n');
         const text = lines.slice(lines.length - parsed.lines - 1, lines.length).join('\n');
-        return respondRaw({ content: [{ type: 'text', text }] });
+        return respondOk(text, { structuredContent: { log: text } });
     },
 } as const);

src/tools/structured_output_schemas.ts

@@ -549,6 +549,15 @@ const actorRunListItemSchema = {
 /** Schema for get-actor-run-list output (paginated list of runs). */
 export const actorRunListOutputSchema = paginatedListOutputSchema(actorRunListItemSchema, 'Actor runs.');
 
+/** Schema for get-actor-run-log output. Plain-text log wrapped for uniformity (#1160). */
+export const getActorRunLogToolOutputSchema = {
+    type: 'object' as const,
+    properties: {
+        log: { type: 'string', description: 'Last N lines of the run log (plain text).' },
+    },
+    required: ['log'],
+};
+
 /**
  * Schema for dataset items retrieval tools (get-dataset-items).
  * Contains dataset items with pagination and count information.

tests/unit/tools.get_actor_run_log.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { HELPER_TOOLS } from '../../src/const.js';
+import { getActorRunLog } from '../../src/tools/runs/get_actor_run_log.js';
+import { getActorRunLogToolOutputSchema } from '../../src/tools/structured_output_schemas.js';
+import type { HelperTool, InternalToolArgs } from '../../src/types.js';
+import {
+    expectSchemaConformingStructuredContent,
+    stubToolCallContext,
+    type TextToolResult,
+} from './helpers/tool_context.js';
+
+const getMock = vi.fn();
+const logMock = vi.fn(() => ({ get: getMock }));
+const runMock = vi.fn(() => ({ log: logMock }));
+
+const stubClient = { run: runMock } as unknown as InternalToolArgs['apifyClient'];
+
+const LOG_LINES = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`);
+const LOG_TEXT = LOG_LINES.join('\n');
+
+describe('get-actor-run-log', () => {
+    it('has the expected tool name', () => {
+        expect(getActorRunLog.name).toBe(HELPER_TOOLS.ACTOR_RUNS_LOG);
+    });
+
+    it('declares an outputSchema', () => {
+        expect((getActorRunLog as HelperTool).outputSchema).toMatchObject({ type: 'object' });
+    });
+
+    it('returns the last N lines matching the tool slicing', async () => {
+        getMock.mockResolvedValue(LOG_TEXT);
+
+        const result = await (getActorRunLog as HelperTool).call(
+            stubToolCallContext({ runId: 'run-1', lines: 5 }, stubClient),
+        );
+        const { content } = result as TextToolResult;
+
+        // Expected derived from the same slice expression the tool uses (current behavior; the -1
+        // off-by-one is intentional and out of scope here).
+        const expected = LOG_LINES.slice(LOG_LINES.length - 5 - 1, LOG_LINES.length).join('\n');
+        expect(content[0].text).toBe(expected);
+        expect(runMock).toHaveBeenCalledWith('run-1');
+    });
+
+    it('mirrors the text content in structuredContent.log', async () => {
+        getMock.mockResolvedValue(LOG_TEXT);
+
+        const result = await (getActorRunLog as HelperTool).call(
+            stubToolCallContext({ runId: 'run-1', lines: 5 }, stubClient),
+        );
+        const { content, structuredContent } = result as TextToolResult;
+
+        expect((structuredContent as { log: string }).log).toBe(content[0].text);
+    });
+
+    it('emits structuredContent conforming to the outputSchema', async () => {
+        getMock.mockResolvedValue(LOG_TEXT);
+
+        const result = await (getActorRunLog as HelperTool).call(
+            stubToolCallContext({ runId: 'run-1', lines: 5 }, stubClient),
+        );
+
+        expectSchemaConformingStructuredContent(result, getActorRunLogToolOutputSchema);
+    });
+});