[Agent Builder] get rid of the answering step

x-pack/platform/packages/shared/agent-builder/agent-builder-common/agents/execution_errors.ts

@@ -20,6 +20,8 @@ export enum AgentExecutionErrorCode {
   invalidState = 'invalid_state',
   /** connector returned an HTTP error (4xx, 5xx) - status propagated to client */
   connectorError = 'connector_error',
+  /** agent did not produce a final answer within its cycle budget */
+  cycleLimitExceeded = 'cycle_limit_exceeded',
 }
 
 export interface ToolNotFoundErrorMeta {
@@ -50,6 +52,7 @@ interface ExecutionErrorMetaMap {
   [AgentExecutionErrorCode.invalidState]: {};
   [AgentExecutionErrorCode.emptyResponse]: {};
   [AgentExecutionErrorCode.connectorError]: ConnectorErrorMeta;
+  [AgentExecutionErrorCode.cycleLimitExceeded]: {};
 }
 
 export type ExecutionErrorMetaOf<ErrCode extends AgentExecutionErrorCode> =

x-pack/platform/packages/shared/agent-builder/agent-builder-genai-utils/langchain/tools.test.ts

@@ -44,6 +44,23 @@ describe('toolToLangchain', () => {
     expect(langchainTool.description).toEqual('desc');
     expect(langchainTool.responseFormat).toEqual('content_and_artifact');
 
+    const toolKeys = Object.keys((langchainTool.schema as any).shape);
+    expect(toolKeys.sort()).toEqual(['foo']);
+  });
+
+  it('adds reasoning param when specified', async () => {
+    const tool = createTool('toolA', {
+      description: 'desc',
+      getSchema: () => z.object({ foo: z.string() }),
+    });
+
+    const langchainTool = await toolToLangchain({
+      tool,
+      toolId: tool.id,
+      logger,
+      addReasoningParam: true,
+    });
+
     const toolKeys = Object.keys((langchainTool.schema as any).shape);
     expect(toolKeys.sort()).toEqual(['_reasoning', 'foo']);
   });

x-pack/platform/packages/shared/agent-builder/agent-builder-genai-utils/langchain/tools.ts

@@ -104,7 +104,7 @@ export const toolToLangchain = async ({
   toolId,
   logger,
   sendEvent,
-  addReasoningParam = true,
+  addReasoningParam = false,
 }: {
   tool: ExecutableTool;
   toolId?: string;

x-pack/platform/plugins/shared/agent_builder/server/services/execution/run_agent/action_utils.ts

@@ -9,7 +9,6 @@ import type { AIMessageChunk, BaseMessage, ToolMessage } from '@langchain/core/m
 import { isToolMessage } from '@langchain/core/messages';
 import {
   extractTextContent,
-  extractToolCalls,
   extractToolCallsWithReasoning,
 } from '@kbn/agent-builder-genai-utils/langchain';
 import { createAgentExecutionError } from '@kbn/agent-builder-common/base/errors';
@@ -22,15 +21,13 @@ import type {
   AgentErrorAction,
   ExecuteToolAction,
   ToolPromptAction,
-  AnswerAction,
   StructuredAnswerAction,
 } from './actions';
 import {
   toolCallAction,
   handoverAction,
   executeToolAction,
   toolPromptAction,
-  answerAction,
   errorAction,
   structuredAnswerAction,
 } from './actions';
@@ -121,56 +118,20 @@ export const processToolNodeResponse = (
   return actions;
 };
 
-export const processAnswerResponse = (message: AIMessageChunk): AnswerAction | AgentErrorAction => {
-  // The answering agent should not call tools. Some models/providers can still emit tool calls
-  // unexpectedly, so we treat that as a recoverable error and retry with an explicit tool-result
-  // error message in the prompt history.
-  if (message.tool_calls?.length) {
-    const [firstToolCall] = extractToolCalls(message);
-    const toolName = firstToolCall?.toolName ?? 'unknown';
-    const toolArgs = firstToolCall?.args ?? {};
-
-    return errorAction(
-      createAgentExecutionError(
-        `Answer agent attempted to call tool "${toolName}"`,
-        AgentExecutionErrorCode.toolNotFound,
-        { toolName, toolArgs }
-      )
-    );
-  }
-
-  const textContent = extractTextContent(message);
-  if (textContent) {
-    return answerAction(extractTextContent(message));
-  } else {
+export const processStructuredAnswerResponse = (
+  response: unknown
+): StructuredAnswerAction | AgentErrorAction => {
+  try {
+    if (response && typeof response === 'object') {
+      return structuredAnswerAction(response);
+    }
     return errorAction(
       createAgentExecutionError(
-        'agent returned an empty response',
+        'agent returned an invalid structured response',
         AgentExecutionErrorCode.emptyResponse,
         {}
       )
     );
-  }
-};
-
-export const processStructuredAnswerResponse = (
-  response: unknown
-): StructuredAnswerAction | AnswerAction | AgentErrorAction => {
-  try {
-    if (response && typeof response === 'object') {
-      const action = structuredAnswerAction(response);
-      return action;
-    } else if (typeof response === 'string') {
-      return answerAction(response);
-    } else {
-      return errorAction(
-        createAgentExecutionError(
-          'agent returned an invalid structured response',
-          AgentExecutionErrorCode.emptyResponse,
-          {}
-        )
-      );
-    }
   } catch (error) {
     return errorAction(
       createAgentExecutionError(

x-pack/platform/plugins/shared/agent_builder/server/services/execution/run_agent/actions.ts

@@ -17,7 +17,6 @@ export enum AgentActionType {
   ExecuteTool = 'execute_tool',
   ToolPrompt = 'tool_prompt',
   HandOver = 'hand_over',
-  Answer = 'answer',
   StructuredAnswer = 'structured_answer',
   BackgroundExecutionComplete = 'background_execution_complete',
 }
@@ -82,17 +81,12 @@ export type ResearchAgentAction =
 
 // answer phase actions
 
-export interface AnswerAction {
-  type: AgentActionType.Answer;
-  message: string;
-}
-
 export interface StructuredAnswerAction {
   type: AgentActionType.StructuredAnswer;
   data: object;
 }
 
-export type AnswerAgentAction = AnswerAction | StructuredAnswerAction | AgentErrorAction;
+export type AnswerAgentAction = StructuredAnswerAction | AgentErrorAction;
 
 // all possible actions for the agent flow
 
@@ -120,10 +114,6 @@ export function isHandoverAction(action: AgentAction): action is HandoverAction
   return action.type === AgentActionType.HandOver;
 }
 
-export function isAnswerAction(action: AgentAction): action is AnswerAction {
-  return action.type === AgentActionType.Answer;
-}
-
 export function isStructuredAnswerAction(action: AgentAction): action is StructuredAnswerAction {
   return action.type === AgentActionType.StructuredAnswer;
 }
@@ -190,13 +180,6 @@ export function handoverAction(message: string, forceful: boolean = false): Hand
   };
 }
 
-export function answerAction(message: string): AnswerAction {
-  return {
-    type: AgentActionType.Answer,
-    message,
-  };
-}
-
 export function structuredAnswerAction(data: object): StructuredAnswerAction {
   return {
     type: AgentActionType.StructuredAnswer,