Method execute_subsession

crates/opencode-agent/src/executor.rs:212–264

(
        &mut self,
        user_message: impl Into<String>,
    )

    }

    async fn execute_subsession(
        &mut self,
        user_message: impl Into<String>,
    ) -> Result<String, AgentError> {
        self.conversation.add_user_message(user_message);

        let mut steps = 0;
        let mut final_response = String::new();

        while steps < self.max_steps {
            steps += 1;

            let provider = self.get_provider()?;
            let model_id = self.get_model_id(&provider);
            let request = ChatRequest::new(model_id, self.conversation.to_provider_messages());

            let stream = provider
                .chat_stream(request)
                .await
                .map_err(|e| AgentError::ProviderError(e.to_string()))?;

            let (response, tool_calls) = self.process_stream(stream).await?;

            if tool_calls.is_empty() {
                final_response = response;
                break;
            }

            self.conversation.add_assistant_message(&response);

            for tool_call in tool_calls {
                let result = self.execute_tool_without_subsessions(&tool_call).await;

                let (content, is_error) = match result {
                    Ok(output) => (output, false),
                    Err(e) => (e.to_string(), true),
                };

                self.conversation.add_tool_result(
                    &tool_call.id,
                    &tool_call.name,
                    content,
                    is_error,
                );
            }
        }

        if steps >= self.max_steps {
            return Err(AgentError::MaxStepsExceeded);
        }

        Ok(final_response)
    }

    pub async fn execute_streaming(
        &mut self,